



'''simple docstring'''

import pickle

import numpy as np
from matplotlib import pyplot as plt

class __snake_case:


						'''simple docstring'''



						def __init__(   self      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_=0.2      ,			A_=0.2 )      ->      Optional[Any]:
							lowerCAmelCase       =      bp_numa
							lowerCAmelCase       =      bp_numa
							lowerCAmelCase       =      bp_numa
							lowerCAmelCase       =      conva_get[:2]
							lowerCAmelCase       =      conva_get[2]
							lowerCAmelCase       =      size_pa
							lowerCAmelCase       =      rate_w
							lowerCAmelCase       =      rate_t
							lowerCAmelCase       =      [
							    np.mat(-1 * np.random.rand(self.conva[0]      ,			self.conva[0] ) + 0.5 )
							    for i in range(self.conva[1] )
							]
							lowerCAmelCase       =      np.mat(-1 * np.random.rand(self.num_bpa      ,			self.num_bpa ) + 0.5 )
							lowerCAmelCase       =      np.mat(-1 * np.random.rand(self.num_bpa      ,			self.num_bpa ) + 0.5 )
							lowerCAmelCase       =      -2 * np.random.rand(self.conva[1] ) + 1
							lowerCAmelCase       =      -2 * np.random.rand(self.num_bpa ) + 1
							lowerCAmelCase       =      -2 * np.random.rand(self.num_bpa ) + 1


						def 							__snake_case       (   self      ,			A_ )      ->      Optional[Any]:
							# save model dict with pickle
							lowerCAmelCase       =      {
							    """num_bp1""": self.num_bpa,
							    """num_bp2""": self.num_bpa,
							    """num_bp3""": self.num_bpa,
							    """conv1""": self.conva,
							    """step_conv1""": self.step_conva,
							    """size_pooling1""": self.size_poolinga,
							    """rate_weight""": self.rate_weight,
							    """rate_thre""": self.rate_thre,
							    """w_conv1""": self.w_conva,
							    """wkj""": self.wkj,
							    """vji""": self.vji,
							    """thre_conv1""": self.thre_conva,
							    """thre_bp2""": self.thre_bpa,
							    """thre_bp3""": self.thre_bpa,
							}
							with open(A_      ,			"""wb""" ) as f:
								pickle.dump(A_      ,			A_ )

							print(f'Model saved： {save_path}' )


						@classmethod
						def 							__snake_case       (   cls      ,			A_ )      ->      Dict:
							# read saved model
							with open(A_      ,			"""rb""" ) as f:
								lowerCAmelCase       =      pickle.load(A_ )  # noqa: S301

							lowerCAmelCase       =      model_dic.get("""conv1""" )
							conv_get.append(model_dic.get("""step_conv1""" ) )
							lowerCAmelCase       =      model_dic.get("""size_pooling1""" )
							lowerCAmelCase       =      model_dic.get("""num_bp1""" )
							lowerCAmelCase       =      model_dic.get("""num_bp2""" )
							lowerCAmelCase       =      model_dic.get("""num_bp3""" )
							lowerCAmelCase       =      model_dic.get("""rate_weight""" )
							lowerCAmelCase       =      model_dic.get("""rate_thre""" )
							# create model instance
							lowerCAmelCase       =      CNN(A_      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_ )
							# modify model parameter
							lowerCAmelCase       =      model_dic.get("""w_conv1""" )
							lowerCAmelCase       =      model_dic.get("""wkj""" )
							lowerCAmelCase       =      model_dic.get("""vji""" )
							lowerCAmelCase       =      model_dic.get("""thre_conv1""" )
							lowerCAmelCase       =      model_dic.get("""thre_bp2""" )
							lowerCAmelCase       =      model_dic.get("""thre_bp3""" )
							return conv_ins


						def 							__snake_case       (   self      ,			A_ )      ->      List[Any]:
							return 1 / (1 + np.exp(-1 * x ))


						def 							__snake_case       (   self      ,			A_ )      ->      List[str]:
							return round(A_      ,			3 )


						def 							__snake_case       (   self      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_ )      ->      Optional[Any]:
							# convolution process
							lowerCAmelCase       =      convs[0]
							lowerCAmelCase       =      convs[1]
							lowerCAmelCase       =      np.shape(A_ )[0]
							# get the data slice of original image data, data_focus
							lowerCAmelCase       =      []
							for i_focus in range(0      ,			size_data - size_conv + 1      ,			A_ ):
								for j_focus in range(0      ,			size_data - size_conv + 1      ,			A_ ):
									lowerCAmelCase       =      data[
									    i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
									]
									data_focus.append(A_ )
        # calculate the feature map of every single kernel, and saved as list of matrix
							lowerCAmelCase       =      []
							lowerCAmelCase       =      int((size_data - size_conv) / conv_step + 1 )
							for i_map in range(A_ ):
								lowerCAmelCase       =      []
								for i_focus in range(len(A_ ) ):
									lowerCAmelCase       =      (
									    np.sum(np.multiply(data_focus[i_focus]      ,			w_convs[i_map] ) )
									    - thre_convs[i_map]
									)
									featuremap.append(self.sig(A_ ) )
								lowerCAmelCase       =      np.asmatrix(A_ ).reshape(
								    A_      ,			A_ )
								data_featuremap.append(A_ )

							# expanding the data slice to One dimenssion
							lowerCAmelCase       =      []
							for each_focus in data_focus:
								focusa_list.extend(self.Expand_Mat(A_ ) )
							lowerCAmelCase       =      np.asarray(A_ )
							return focus_list, data_featuremap


						def 							__snake_case       (   self      ,			A_      ,			A_      ,			A_="average_pool" )      ->      List[Any]:
							# pooling process
							lowerCAmelCase       =      len(featuremaps[0] )
							lowerCAmelCase       =      int(size_map / size_pooling )
							lowerCAmelCase       =      []
							for i_map in range(len(A_ ) ):
								lowerCAmelCase       =      featuremaps[i_map]
								lowerCAmelCase       =      []
								for i_focus in range(0      ,			A_      ,			A_ ):
									for j_focus in range(0      ,			A_      ,			A_ ):
										lowerCAmelCase       =      feature_map[
										    i_focus : i_focus + size_pooling,
										    j_focus : j_focus + size_pooling,
										]
										if pooling_type == "average_pool":
											# average pooling
											map_pooled.append(np.average(A_ ) )
										elif pooling_type == "max_pooling":
											# max pooling
											map_pooled.append(np.max(A_ ) )
								lowerCAmelCase       =      np.asmatrix(A_ ).reshape(A_      ,			A_ )
								featuremap_pooled.append(A_ )
							return featuremap_pooled


						def 							__snake_case       (   self      ,			A_ )      ->      List[str]:
							# expanding three dimension data to one dimension list
							lowerCAmelCase       =      []
							for i in range(len(A_ ) ):
								lowerCAmelCase       =      np.shape(data[i] )
								lowerCAmelCase       =      data[i].reshape(1      ,			shapes[0] * shapes[1] )
								lowerCAmelCase       =      data_listed.getA().tolist()[0]
								data_expanded.extend(A_ )
							lowerCAmelCase       =      np.asarray(A_ )
							return data_expanded


						def 							__snake_case       (   self      ,			A_ )      ->      Optional[Any]:
							# expanding matrix to one dimension list
							lowerCAmelCase       =      np.asarray(A_ )
							lowerCAmelCase       =      np.shape(A_ )
							lowerCAmelCase       =      data_mat.reshape(1      ,			shapes[0] * shapes[1] )
							return data_expanded


						def 							__snake_case       (   self      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_ )      ->      Tuple:
							lowerCAmelCase       =      []
							lowerCAmelCase       =      0
							for i_map in range(A_ ):
								lowerCAmelCase       =      np.ones((size_map, size_map) )
								for i in range(0      ,			A_      ,			A_ ):
									for j in range(0      ,			A_      ,			A_ ):
										lowerCAmelCase       =      pd_pool[
										    i_pool
										]
										lowerCAmelCase       =      i_pool + 1
								lowerCAmelCase       =      np.multiply(
								    A_      ,			np.multiply(out_map[i_map]      ,			(1 - out_map[i_map]) ) )
								pd_all.append(A_ )
							return pd_all


						def 							__snake_case       (   self      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_      ,			A_=bool )      ->      Optional[Any]:
							# model traning
							print("""----------------------Start Training-------------------------""" )
							print((""" - - Shape: Train_Data  """, np.shape(A_ )) )
							print((""" - - Shape: Teach_Data  """, np.shape(A_ )) )
							lowerCAmelCase       =      0
							lowerCAmelCase       =      []
							lowerCAmelCase       =      1_0000
							while rp < n_repeat and mse >= error_accuracy:
								lowerCAmelCase       =      0
								print(f'-------------Learning Time {rp}--------------' )
								for p in range(len(A_ ) ):
									# print('------------Learning Image: %d--------------'%p)
									lowerCAmelCase       =      np.asmatrix(datas_train[p] )
									lowerCAmelCase       =      np.asarray(datas_teach[p] )
									lowerCAmelCase,  lowerCAmelCase       =      self.convolute(
									    A_      ,			self.conva      ,			self.w_conva      ,			self.thre_conva      ,			conv_step=self.step_conva      ,			)
									lowerCAmelCase       =      self.pooling(A_      ,			self.size_poolinga )
									lowerCAmelCase       =      np.shape(A_ )
									lowerCAmelCase       =      self._expand(A_ )
									lowerCAmelCase       =      data_bp_input

									lowerCAmelCase       =      np.dot(A_      ,			self.vji.T ) - self.thre_bpa
									lowerCAmelCase       =      self.sig(A_ )
									lowerCAmelCase       =      np.dot(A_      ,			self.wkj.T ) - self.thre_bpa
									lowerCAmelCase       =      self.sig(A_ )

									# --------------Model Leaning ------------------------
									# calculate error and gradient---------------
									lowerCAmelCase       =      np.multiply(
									    (data_teach - bp_outa)      ,			np.multiply(A_      ,			(1 - bp_outa) ) )
									lowerCAmelCase       =      np.multiply(
									    np.dot(A_      ,			self.wkj )      ,			np.multiply(A_      ,			(1 - bp_outa) ) )
									lowerCAmelCase       =      np.dot(A_      ,			self.vji )

									lowerCAmelCase       =      pd_i_all / (self.size_poolinga * self.size_poolinga)
									lowerCAmelCase       =      pd_conva_pooled.T.getA().tolist()
									lowerCAmelCase       =      self._calculate_gradient_from_pool(
									    A_      ,			A_      ,			shape_featuremapa[0]      ,			shape_featuremapa[1]      ,			self.size_poolinga      ,			)
									# weight and threshold learning process---------
									# convolution layer
									for k_conv in range(self.conva[1] ):
										lowerCAmelCase       =      self._expand_mat(pd_conva_all[k_conv] )
										lowerCAmelCase       =      self.rate_weight * np.dot(A_      ,			A_ )

										lowerCAmelCase       =      self.w_conva[k_conv] + delta_w.reshape(
										    (self.conva[0], self.conva[0]) )

										lowerCAmelCase       =      (
										    self.thre_conva[k_conv]
										    - np.sum(pd_conva_all[k_conv] ) * self.rate_thre
										)
									# all connected layer
									lowerCAmelCase       =      self.wkj + pd_k_all.T * bp_outa * self.rate_weight
									lowerCAmelCase       =      self.vji + pd_j_all.T * bp_outa * self.rate_weight
									lowerCAmelCase       =      self.thre_bpa - pd_k_all * self.rate_thre
									lowerCAmelCase       =      self.thre_bpa - pd_j_all * self.rate_thre
									# calculate the sum error of all single image
									lowerCAmelCase       =      np.sum(abs(data_teach - bp_outa ) )
									error_count += errors
									# print('   ----Teach      ',data_teach)
									# print('   ----BP_output  ',bp_out3)
								lowerCAmelCase       =      rp + 1
								lowerCAmelCase       =      error_count / patterns
								all_mse.append(A_ )

							def draw_error():
								lowerCAmelCase       =      [error_accuracy for i in range(int(n_repeat * 1.2 ) )]
								plt.plot(A_      ,			"""+-""" )
								plt.plot(A_      ,			"""r--""" )
								plt.xlabel("""Learning Times""" )
								plt.ylabel("""All_mse""" )
								plt.grid(A_      ,			alpha=0.5 )
								plt.show()

							print("""------------------Training Complished---------------------""" )
							print((""" - - Training epoch: """, rp, f'     - - Mse: {mse:.6f}') )
							if draw_e:
								draw_error()
							return mse


						def 							__snake_case       (   self      ,			A_ )      ->      Union[str, Any]:
							# model predict
							lowerCAmelCase       =      []
							print("""-------------------Start Testing-------------------------""" )
							print((""" - - Shape: Test_Data  """, np.shape(A_ )) )
							for p in range(len(A_ ) ):
								lowerCAmelCase       =      np.asmatrix(datas_test[p] )
								lowerCAmelCase,  lowerCAmelCase       =      self.convolute(
								    A_      ,			self.conva      ,			self.w_conva      ,			self.thre_conva      ,			conv_step=self.step_conva      ,			)
								lowerCAmelCase       =      self.pooling(A_      ,			self.size_poolinga )
								lowerCAmelCase       =      self._expand(A_ )

								lowerCAmelCase       =      data_bp_input
								lowerCAmelCase       =      bp_outa * self.vji.T - self.thre_bpa
								lowerCAmelCase       =      self.sig(A_ )
								lowerCAmelCase       =      bp_outa * self.wkj.T - self.thre_bpa
								lowerCAmelCase       =      self.sig(A_ )
								produce_out.extend(bp_outa.getA().tolist() )
							lowerCAmelCase       =      [list(map(self.do_round      ,			A_ ) ) for each in produce_out]
							return np.asarray(A_ )




						def 							__snake_case       (   self      ,			A_ )      ->      Any:
							# return the data of image after convoluting process so we can check it out
							lowerCAmelCase       =      np.asmatrix(A_ )
							lowerCAmelCase,  lowerCAmelCase       =      self.convolute(
							    A_      ,			self.conva      ,			self.w_conva      ,			self.thre_conva      ,			conv_step=self.step_conva      ,			)
							lowerCAmelCase       =      self.pooling(A_      ,			self.size_poolinga )

							return data_conveda, data_pooleda


if __name__ == "__main__":
				pass

"""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 					lowerCAmelCase_					(   _lowercase		,       unittest.TestCase     ):



						'''simple docstring'''


						_lowerCamelCase:     Dict   =     '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''


						def     _SCREAMING_SNAKE_CASE   (			self  :   Any	,A_  :   List[str]=0   )  -> str:
							A     = floats_tensor((1, 3, 128, 128)	,rng=random.Random(A_   )   )
							A     = np.random.RandomState(A_   )
							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     _SCREAMING_SNAKE_CASE   (			self  :   Dict   )  -> Tuple:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							pipe.set_progress_bar_config(disable=A_   )

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.6_96_43, 0.5_84_84, 0.5_03_14, 0.5_87_60, 0.5_53_68, 0.5_96_43, 0.5_15_29, 0.4_12_17, 0.4_90_87]   )
							assert np.abs(image_slice - expected_slice   ).max() < 1e-1


						def     _SCREAMING_SNAKE_CASE   (			self  :   List[Any]   )  -> Any:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							A     = PNDMScheduler.from_config(pipe.scheduler.config	,skip_prk_steps=A_   )
							pipe.set_progress_bar_config(disable=A_   )

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.6_17_37, 0.5_46_42, 0.5_31_83, 0.5_44_65, 0.5_27_42, 0.6_05_25, 0.4_99_69, 0.4_06_55, 0.4_81_54]   )

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


						def     _SCREAMING_SNAKE_CASE   (			self  :   Union[str, Any]   )  -> int:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							A     = LMSDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=A_   )

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

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.5_27_61, 0.5_99_77, 0.4_90_33, 0.4_96_19, 0.5_42_82, 0.5_03_11, 0.4_76_00, 0.4_09_18, 0.4_52_03]   )

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


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[int]   )  -> Tuple:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							A     = EulerDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=A_   )

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]   )

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


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]   )  -> str:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							A     = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=A_   )

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]   )

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




						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> Tuple:
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint	,provider='CPUExecutionProvider'   )
							A     = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=A_   )

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

							assert image.shape == (1, 128, 128, 3)
							A     = np.array([0.6_53_31, 0.5_82_77, 0.4_82_04, 0.5_60_59, 0.5_36_65, 0.5_62_35, 0.5_09_69, 0.4_00_09, 0.4_65_52]   )

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







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



						'''simple docstring'''


						@property
						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> Union[str, Any]:
							return (
							    "CUDAExecutionProvider",
							    {
							        "gpu_mem_limit": "15000000000",  # 15GB
							        "arena_extend_strategy": "kSameAsRequested",
							    },
							)


						@property
						def     _SCREAMING_SNAKE_CASE   (			self  :   str   )  -> List[Any]:
							A     = ort.SessionOptions()
							A     = False
							return options


						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> str:
							A     = load_image(
							    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
							    '/img2img/sketch-mountains-input.jpg'   )
							A     = init_image.resize((768, 512)   )
							# using the PNDM scheduler by default
							A     = OnnxStableDiffusionImgaImgPipeline.from_pretrained(
							    'CompVis/stable-diffusion-v1-4'	,revision='onnx'	,safety_checker=A_	,feature_extractor=A_	,provider=self.gpu_provider	,sess_options=self.gpu_options	,)
							pipe.set_progress_bar_config(disable=A_   )

							A     = 'A fantasy landscape, trending on artstation'

							A     = np.random.RandomState(0   )
							A     = pipe(
							    prompt=A_	,image=A_	,strength=0.75	,guidance_scale=7.5	,num_inference_steps=10	,generator=A_	,output_type='np'	,)
							A     = output.images
							A     = images[0, 255:258, 383:386, -1]

							assert images.shape == (1, 512, 768, 3)
							A     = np.array([0.49_09, 0.50_59, 0.53_72, 0.46_23, 0.48_76, 0.50_49, 0.48_20, 0.49_56, 0.50_19]   )
							# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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




						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[int]   )  -> Optional[Any]:
							A     = load_image(
							    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
							    '/img2img/sketch-mountains-input.jpg'   )
							A     = init_image.resize((768, 512)   )
							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=A_	,safety_checker=A_	,feature_extractor=A_	,provider=self.gpu_provider	,sess_options=self.gpu_options	,)
							pipe.set_progress_bar_config(disable=A_   )

							A     = 'A fantasy landscape, trending on artstation'

							A     = np.random.RandomState(0   )
							A     = pipe(
							    prompt=A_	,image=A_	,strength=0.75	,guidance_scale=7.5	,num_inference_steps=20	,generator=A_	,output_type='np'	,)
							A     = output.images
							A     = images[0, 255:258, 383:386, -1]

							assert images.shape == (1, 512, 768, 3)
							A     = np.array([0.80_43, 0.9_26, 0.95_81, 0.81_19, 0.89_54, 0.9_13, 0.72_09, 0.74_63, 0.74_31]   )
							# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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