


'''simple docstring'''




from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


__snake_case    						=logging.get_logger(__name__)

# General docstring
__snake_case    						="""RegNetConfig"""

# Base docstring
__snake_case    						="""facebook/regnet-y-040"""
__snake_case    						=[1, 1_088, 7, 7]

# Image classification docstring
__snake_case    						="""facebook/regnet-y-040"""
__snake_case    						="""tabby, tabby cat"""

__snake_case    						=[
    """facebook/regnet-y-040""",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      List[Any]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 3    ,      UpperCAmelCase__       :      int = 1    ,      UpperCAmelCase__       :      int = 1    ,      UpperCAmelCase__       :      Optional[str] = "relu"    ,      )				->  Any:
        super().__init__()
        lowerCAmelCase     =			nn.Convad(
            UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      padding=kernel_size // 2    ,      groups=UpperCAmelCase__    ,      bias=UpperCAmelCase__    ,      )
        lowerCAmelCase     =			nn.BatchNormad(UpperCAmelCase__    )
        lowerCAmelCase     =			ACTaFN[activation] if activation is not None else nn.Identity()





     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Tuple    )				->  Tuple:
        lowerCAmelCase     =			self.convolution(UpperCAmelCase__    )
        lowerCAmelCase     =			self.normalization(UpperCAmelCase__    )
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      RegNetConfig    )				->  Tuple:
        super().__init__()
        lowerCAmelCase     =			RegNetConvLayer(
            config.num_channels    ,      config.embedding_size    ,      kernel_size=3    ,      stride=2    ,      activation=config.hidden_act    )
        lowerCAmelCase     =			config.num_channels





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Optional[Any]    )				->  Any:
        lowerCAmelCase     =			pixel_values.shape[1]
        if num_channels != self.num_channels:
           raise ValueError(
               'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'    )
        lowerCAmelCase     =			self.embedder(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Tuple    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 2    )				->  Optional[int]:
        super().__init__()
        lowerCAmelCase     =			nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      stride=UpperCAmelCase__    ,      bias=UpperCAmelCase__    )
        lowerCAmelCase     =			nn.BatchNormad(UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Tensor    )				->  Tensor:
        lowerCAmelCase     =			self.convolution(UpperCAmelCase__    )
        lowerCAmelCase     =			self.normalization(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Any    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  Union[str, Any]:
        super().__init__()

        lowerCAmelCase     =			nn.AdaptiveAvgPoolad((1, 1)    )
        lowerCAmelCase     =			nn.Sequential(
            nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    )    ,      nn.ReLU()    ,      nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    )    ,      nn.Sigmoid()    ,      )





     def 							__UpperCAmelCase      ( self       :      Tuple    ,      UpperCAmelCase__       :      str    )				->  Optional[Any]:
        # b c h w -> b c 1 1
        lowerCAmelCase     =			self.pooler(UpperCAmelCase__    )
        lowerCAmelCase     =			self.attention(UpperCAmelCase__    )
        lowerCAmelCase     =			hidden_state * attention
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 1    )				->  Optional[int]:
        super().__init__()
        lowerCAmelCase     =			in_channels != out_channels or stride != 1
        lowerCAmelCase     =			max(1    ,      out_channels // config.groups_width    )
        lowerCAmelCase     =			(
            RegNetShortCut(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ) if should_apply_shortcut else nn.Identity()
        )
        lowerCAmelCase     =			nn.Sequential(
            RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      groups=UpperCAmelCase__    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=UpperCAmelCase__    )    ,      )
        lowerCAmelCase     =			ACTaFN[config.hidden_act]





     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Any    )				->  Union[str, Any]:
        lowerCAmelCase     =			hidden_state
        lowerCAmelCase     =			self.layer(UpperCAmelCase__    )
        lowerCAmelCase     =			self.shortcut(UpperCAmelCase__    )
        hidden_state += residual
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      str    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 1    )				->  Optional[Any]:
        super().__init__()
        lowerCAmelCase     =			in_channels != out_channels or stride != 1
        lowerCAmelCase     =			max(1    ,      out_channels // config.groups_width    )
        lowerCAmelCase     =			(
            RegNetShortCut(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ) if should_apply_shortcut else nn.Identity()
        )
        lowerCAmelCase     =			nn.Sequential(
            RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      groups=UpperCAmelCase__    ,      activation=config.hidden_act    )    ,      RegNetSELayer(UpperCAmelCase__    ,      reduced_channels=int(round(in_channels / 4    )    )    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=UpperCAmelCase__    )    ,      )
        lowerCAmelCase     =			ACTaFN[config.hidden_act]





     def 							__UpperCAmelCase      ( self       :      Any    ,      UpperCAmelCase__       :      Union[str, Any]    )				->  Tuple:
        lowerCAmelCase     =			hidden_state
        lowerCAmelCase     =			self.layer(UpperCAmelCase__    )
        lowerCAmelCase     =			self.shortcut(UpperCAmelCase__    )
        hidden_state += residual
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 2    ,      UpperCAmelCase__       :      int = 2    ,      )				->  Optional[Any]:
        super().__init__()

        lowerCAmelCase     =			RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

        lowerCAmelCase     =			nn.Sequential(
            # downsampling is done in the first layer with stride of 2
            layer(
                UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      )    ,      *[layer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ) for _ in range(depth - 1    )]    ,      )





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    ,      UpperCAmelCase__       :      List[str]    )				->  Tuple:
        lowerCAmelCase     =			self.layers(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Any    ,      UpperCAmelCase__       :      RegNetConfig    )				->  Dict:
        super().__init__()
        lowerCAmelCase     =			nn.ModuleList([]    )
        # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
        self.stages.append(
            RegNetStage(
                UpperCAmelCase__    ,      config.embedding_size    ,      config.hidden_sizes[0]    ,      stride=2 if config.downsample_in_first_stage else 1    ,      depth=config.depths[0]    ,      )    )
        lowerCAmelCase     =			zip(config.hidden_sizes    ,      config.hidden_sizes[1:]    )
        for (in_channels, out_channels), depth in zip(UpperCAmelCase__    ,      config.depths[1:]    ):
           self.stages.append(RegNetStage(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ,      depth=UpperCAmelCase__    )    )





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Tensor    ,      UpperCAmelCase__       :      bool = False    ,      UpperCAmelCase__       :      bool = True    )				->  BaseModelOutputWithNoAttention:
        lowerCAmelCase     =			() if output_hidden_states else None

        for stage_module in self.stages:
           if output_hidden_states:
              lowerCAmelCase     =			hidden_states + (hidden_state,)

           lowerCAmelCase     =			stage_module(UpperCAmelCase__    )

        if output_hidden_states:
           lowerCAmelCase     =			hidden_states + (hidden_state,)

        if not return_dict:
           return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

        return BaseModelOutputWithNoAttention(last_hidden_state=UpperCAmelCase__    ,      hidden_states=UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase		):
     lowerCamelCase				:	List[Any]		=     RegNetConfig
     lowerCamelCase				:	Any		=     '''regnet'''
     lowerCamelCase				:	Any		=     '''pixel_values'''
     lowerCamelCase				:	Union[str, Any]		=     True





     def 							__UpperCAmelCase      ( self       :      List[str]    ,      UpperCAmelCase__       :      int    )				->  Optional[int]:
        if isinstance(UpperCAmelCase__    ,      nn.Convad    ):
           nn.init.kaiming_normal_(module.weight    ,      mode='fan_out'    ,      nonlinearity='relu'    )
        elif isinstance(UpperCAmelCase__    ,      (nn.BatchNormad, nn.GroupNorm)    ):
           nn.init.constant_(module.weight    ,      1    )
           nn.init.constant_(module.bias    ,      0    )





     def 							__UpperCAmelCase      ( self       :      str    ,      UpperCAmelCase__       :      Optional[int]    ,      UpperCAmelCase__       :      Tuple=False    )				->  Any:
        if isinstance(UpperCAmelCase__    ,      UpperCAmelCase__    ):
           lowerCAmelCase     =			value




__snake_case    						=R"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

__snake_case    						=R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
"""

@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''       ,	__lowercase       ,	)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 		UpperCAmelCase_      (  __lowercase		):





     def __init__( self       :      List[str]    ,      UpperCAmelCase__       :      Optional[int]    )				->  List[Any]:
        super().__init__(UpperCAmelCase__    )
        lowerCAmelCase     =			config
        lowerCAmelCase     =			RegNetEmbeddings(UpperCAmelCase__    )
        lowerCAmelCase     =			RegNetEncoder(UpperCAmelCase__    )
        lowerCAmelCase     =			nn.AdaptiveAvgPoolad((1, 1)    )
        # Initialize weights and apply final processing
        self.post_init()





     @add_start_docstrings_to_model_forward(UpperCAmelCase__    )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC    ,      output_type=UpperCAmelCase__    ,      config_class=_CONFIG_FOR_DOC    ,      modality='vision'    ,      expected_output=_EXPECTED_OUTPUT_SHAPE    ,      )
     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Tensor    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    )				->  BaseModelOutputWithPoolingAndNoAttention:
        lowerCAmelCase     =			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        lowerCAmelCase     =			return_dict if return_dict is not None else self.config.use_return_dict

        lowerCAmelCase     =			self.embedder(UpperCAmelCase__    )

        lowerCAmelCase     =			self.encoder(
            UpperCAmelCase__    ,      output_hidden_states=UpperCAmelCase__    ,      return_dict=UpperCAmelCase__    )

        lowerCAmelCase     =			encoder_outputs[0]

        lowerCAmelCase     =			self.pooler(UpperCAmelCase__    )

        if not return_dict:
           return (last_hidden_state, pooled_output) + encoder_outputs[1:]

        return BaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=UpperCAmelCase__    ,      pooler_output=UpperCAmelCase__    ,      hidden_states=encoder_outputs.hidden_states    ,      )




@add_start_docstrings(
    '''
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''       ,	__lowercase       ,	)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 		UpperCAmelCase_      (  __lowercase		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      Union[str, Any]    )				->  str:
        super().__init__(UpperCAmelCase__    )
        lowerCAmelCase     =			config.num_labels
        lowerCAmelCase     =			RegNetModel(UpperCAmelCase__    )
        # classification head
        lowerCAmelCase     =			nn.Sequential(
            nn.Flatten()    ,      nn.Linear(config.hidden_sizes[-1]    ,      config.num_labels    ) if config.num_labels > 0 else nn.Identity()    ,      )
        # initialize weights and apply final processing
        self.post_init()





     @add_start_docstrings_to_model_forward(UpperCAmelCase__    )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT    ,      output_type=UpperCAmelCase__    ,      config_class=_CONFIG_FOR_DOC    ,      expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,      )
     def 							__UpperCAmelCase      ( self       :      int    ,      UpperCAmelCase__       :      Optional[torch.FloatTensor] = None    ,      UpperCAmelCase__       :      Optional[torch.LongTensor] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      )				->  ImageClassifierOutputWithNoAttention:
        lowerCAmelCase     =			return_dict if return_dict is not None else self.config.use_return_dict

        lowerCAmelCase     =			self.regnet(UpperCAmelCase__    ,      output_hidden_states=UpperCAmelCase__    ,      return_dict=UpperCAmelCase__    )

        lowerCAmelCase     =			outputs.pooler_output if return_dict else outputs[1]

        lowerCAmelCase     =			self.classifier(UpperCAmelCase__    )

        lowerCAmelCase     =			None

        if labels is not None:
           if self.config.problem_type is None:
              if self.num_labels == 1:
                 lowerCAmelCase     =			'regression'
              elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                 lowerCAmelCase     =			'single_label_classification'
              else:
                 lowerCAmelCase     =			'multi_label_classification'
           if self.config.problem_type == "regression":
              lowerCAmelCase     =			MSELoss()
              if self.num_labels == 1:
                 lowerCAmelCase     =			loss_fct(logits.squeeze()    ,      labels.squeeze()    )
              else:
                 lowerCAmelCase     =			loss_fct(UpperCAmelCase__    ,      UpperCAmelCase__    )
           elif self.config.problem_type == "single_label_classification":
              lowerCAmelCase     =			CrossEntropyLoss()
              lowerCAmelCase     =			loss_fct(logits.view(-1    ,      self.num_labels    )    ,      labels.view(-1    )    )
           elif self.config.problem_type == "multi_label_classification":
              lowerCAmelCase     =			BCEWithLogitsLoss()
              lowerCAmelCase     =			loss_fct(UpperCAmelCase__    ,      UpperCAmelCase__    )

        if not return_dict:
           lowerCAmelCase     =			(logits,) + outputs[2:]
           return (loss,) + output if loss is not None else output

        return ImageClassifierOutputWithNoAttention(loss=UpperCAmelCase__    ,      logits=UpperCAmelCase__    ,      hidden_states=outputs.hidden_states    )









'''simple docstring'''




import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

@slow
@require_torch_gpu
class 		UpperCAmelCase_      (  unittest.TestCase		):





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  int:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Any:
        lowerCAmelCase     =			StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'    )
        lowerCAmelCase     =			sd_pipe.to(UpperCAmelCase__    )
        sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__    )

        sd_pipe.set_scheduler('sample_euler'    )

        lowerCAmelCase     =			'A painting of a squirrel eating a burger'
        lowerCAmelCase     =			torch.manual_seed(0    )
        lowerCAmelCase     =			sd_pipe([prompt]    ,      generator=UpperCAmelCase__    ,      guidance_scale=9.0    ,      num_inference_steps=2_0    ,      output_type='np'    )

        lowerCAmelCase     =			output.images

        lowerCAmelCase     =			image[0, -3:, -3:, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        lowerCAmelCase     =			np.array([0.0_447, 0.0_492, 0.0_468, 0.0_408, 0.0_383, 0.0_408, 0.0_354, 0.0_380, 0.0_339]    )

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





     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Dict:
        lowerCAmelCase     =			StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'    )
        lowerCAmelCase     =			sd_pipe.to(UpperCAmelCase__    )
        sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__    )

        sd_pipe.set_scheduler('sample_euler'    )

        lowerCAmelCase     =			'A painting of a squirrel eating a burger'
        lowerCAmelCase     =			torch.manual_seed(0    )
        lowerCAmelCase     =			sd_pipe([prompt]    ,      generator=UpperCAmelCase__    ,      guidance_scale=9.0    ,      num_inference_steps=2_0    ,      output_type='np'    )

        lowerCAmelCase     =			output.images

        lowerCAmelCase     =			image[0, -3:, -3:, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        lowerCAmelCase     =			np.array([0.1_237, 0.1_320, 0.1_438, 0.1_359, 0.1_390, 0.1_132, 0.1_277, 0.1_175, 0.1_112]    )

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





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  List[str]:
        lowerCAmelCase     =			StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'    )
        lowerCAmelCase     =			sd_pipe.to(UpperCAmelCase__    )
        sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__    )

        sd_pipe.set_scheduler('sample_dpmpp_2m'    )

        lowerCAmelCase     =			'A painting of a squirrel eating a burger'
        lowerCAmelCase     =			torch.manual_seed(0    )
        lowerCAmelCase     =			sd_pipe(
            [prompt]    ,      generator=UpperCAmelCase__    ,      guidance_scale=7.5    ,      num_inference_steps=1_5    ,      output_type='np'    ,      use_karras_sigmas=UpperCAmelCase__    ,      )

        lowerCAmelCase     =			output.images

        lowerCAmelCase     =			image[0, -3:, -3:, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        lowerCAmelCase     =			np.array(
            [0.11_381_689, 0.12_112_921, 0.1_389_457, 0.12_549_606, 0.1_244_964, 0.10_831_517, 0.11_562_866, 0.10_867_816, 0.10_499_048]    )

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





