

import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


_a			=       1_0_0_0






class 							A_			:


     def __init__(							self      :		Any      ,  UpperCAmelCase      :		List[Any]      ,  UpperCAmelCase      :		Tuple=1.2      ,  UpperCAmelCase      :		str="g"      ,  UpperCAmelCase      :		List[Any]=0.5      ,  UpperCAmelCase      :		List[Any]="-"      ,  UpperCAmelCase      :		Optional[int]="test_out.jpg"      ,  UpperCAmelCase      :		Union[str, Any]=True      ,  UpperCAmelCase      :		Tuple=False      ,  UpperCAmelCase      :		Optional[int]=None      ,  UpperCAmelCase      :		Tuple=None      ,  UpperCAmelCase      :		str=0.7      ,  )							->     int:
      if isinstance(UpperCAmelCase      ,  torch.Tensor ):
       __lowerCAmelCase:       Optional[Any]            =				img.numpy().astype('np.uint8' )
      if isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
       __lowerCAmelCase:       int            =				img_tensorize(UpperCAmelCase )
      assert isinstance(UpperCAmelCase      ,  np.ndarray )

      __lowerCAmelCase     ,							__lowerCAmelCase:       int            =				img.shape[1], img.shape[0]
      __lowerCAmelCase:       int            =				mplfigure.Figure(frameon=UpperCAmelCase )
      __lowerCAmelCase:       Optional[int]            =				fig.get_dpi()
      __lowerCAmelCase:       int            =				(width * scale + 1E-2) / dpi
      __lowerCAmelCase:       List[str]            =				(height * scale + 1E-2) / dpi
      fig.set_size_inches(UpperCAmelCase      ,  UpperCAmelCase )
      __lowerCAmelCase:       Optional[Any]            =				fig.add_axes([0.0, 0.0, 1.0, 1.0] )
      ax.axis('off' )
      ax.set_xlim(0.0      ,  UpperCAmelCase )
      ax.set_ylim(UpperCAmelCase )

      __lowerCAmelCase:       Dict            =				saveas
      __lowerCAmelCase:       Tuple            =				rgb
      __lowerCAmelCase:       Union[str, Any]            =				pynb
      __lowerCAmelCase:       Optional[int]            =				img
      __lowerCAmelCase:       int            =				edgecolor
      __lowerCAmelCase:       Dict            =				0.5
      __lowerCAmelCase:       int            =				linestyle
      __lowerCAmelCase:       Any            =				int(np.sqrt(min(UpperCAmelCase      ,  UpperCAmelCase ) ) * scale // 3 )
      __lowerCAmelCase:       int            =				width
      __lowerCAmelCase:       Any            =				height
      __lowerCAmelCase:       Optional[int]            =				scale
      __lowerCAmelCase:       Tuple            =				fig
      __lowerCAmelCase:       List[str]            =				ax
      __lowerCAmelCase:       Any            =				pad
      __lowerCAmelCase:       Union[str, Any]            =				idaobj
      __lowerCAmelCase:       List[Any]            =				idaattr
      __lowerCAmelCase:       Any            =				FigureCanvasAgg(UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		Optional[int]      ,  UpperCAmelCase      :		List[str]=None )							->     str:
      if color is None:
       __lowerCAmelCase:       Optional[int]            =				self.edgecolor
      ((__lowerCAmelCase)     ,							(__lowerCAmelCase)     ,							(__lowerCAmelCase)     ,							(__lowerCAmelCase)):       Optional[Any]            =				box
      __lowerCAmelCase:       List[str]            =				xa - xa
      __lowerCAmelCase:       Any            =				ya - ya
      self.ax.add_patch(
          mpl.patches.Rectangle(
              (xa, ya)      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  fill=UpperCAmelCase      ,  edgecolor=UpperCAmelCase      ,  linewidth=self.font_size // 3      ,  alpha=self.alpha      ,  linestyle=self.linestyle      ,  ) )


     def   UpperCAmelCase  (							self      :		int      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		int=None      ,  UpperCAmelCase      :		Tuple=None      ,  UpperCAmelCase      :		Optional[Any]=None      ,  UpperCAmelCase      :		Dict=None )							->     List[Any]:
      if len(boxes.shape ) > 2:
       __lowerCAmelCase:       List[Any]            =				boxes[0]
      if len(obj_ids.shape ) > 1:
       __lowerCAmelCase:       Optional[int]            =				obj_ids[0]
      if len(obj_scores.shape ) > 1:
       __lowerCAmelCase:       Any            =				obj_scores[0]
      if len(attr_ids.shape ) > 1:
       __lowerCAmelCase:       Optional[Any]            =				attr_ids[0]
      if len(attr_scores.shape ) > 1:
       __lowerCAmelCase:       int            =				attr_scores[0]
      if isinstance(UpperCAmelCase      ,  torch.Tensor ):
       __lowerCAmelCase:       List[str]            =				boxes.numpy()
      if isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
       __lowerCAmelCase:       List[Any]            =				np.array(UpperCAmelCase )
      assert isinstance(UpperCAmelCase      ,  np.ndarray )
      __lowerCAmelCase:       List[str]            =				np.prod(boxes[:, 2:] - boxes[:, :2]      ,  axis=1 )
      __lowerCAmelCase:       List[Any]            =				np.argsort(-areas ).tolist()
      __lowerCAmelCase:       int            =				boxes[sorted_idxs] if boxes is not None else None
      __lowerCAmelCase:       Union[str, Any]            =				obj_ids[sorted_idxs] if obj_ids is not None else None
      __lowerCAmelCase:       List[Any]            =				obj_scores[sorted_idxs] if obj_scores is not None else None
      __lowerCAmelCase:       Union[str, Any]            =				attr_ids[sorted_idxs] if attr_ids is not None else None
      __lowerCAmelCase:       str            =				attr_scores[sorted_idxs] if attr_scores is not None else None

      __lowerCAmelCase:       List[str]            =				[self._random_color(maximum=1 ) for _ in range(len(UpperCAmelCase ) )]
      __lowerCAmelCase:       List[str]            =				[assigned_colors[idx] for idx in sorted_idxs]
      if obj_ids is not None:
       __lowerCAmelCase:       Dict            =				self._create_text_labels_attr(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )
       for i in range(len(UpperCAmelCase ) ):
        __lowerCAmelCase:       Optional[Any]            =				assigned_colors[i]
        self.add_box(boxes[i]      ,  UpperCAmelCase )
        self.draw_labels(labels[i]      ,  boxes[i]      ,  UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		int      ,  UpperCAmelCase      :		Optional[Any]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		Dict )							->     Optional[int]:
      __lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase:       str            =				box
      __lowerCAmelCase:       str            =				(xa, ya)
      __lowerCAmelCase:       int            =				(ya - ya) * (xa - xa)
      __lowerCAmelCase:       List[Any]            =				_SMALL_OBJ * self.scale
      if instance_area < small or ya - ya < 4_0 * self.scale:
       if ya >= self.height - 5:
        __lowerCAmelCase:       str            =				(xa, ya)
       else:
        __lowerCAmelCase:       Dict            =				(xa, ya)

      __lowerCAmelCase:       Optional[int]            =				(ya - ya) / np.sqrt(self.height * self.width )
      __lowerCAmelCase:       str            =				self._change_color_brightness(UpperCAmelCase      ,  brightness_factor=0.7 )
      __lowerCAmelCase:       Any            =				np.clip((height_ratio - 0.02) / 0.08 + 1      ,  1.2      ,  2 )
      font_size *= 0.75 * self.font_size

      self.draw_text(
          text=UpperCAmelCase      ,  position=UpperCAmelCase      ,  color=UpperCAmelCase      ,  )


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		List[str]      ,  UpperCAmelCase      :		Optional[int]      ,  UpperCAmelCase      :		Optional[int]="g"      ,  UpperCAmelCase      :		Optional[int]="left"      ,  )							->     List[Any]:
      __lowerCAmelCase:       Optional[Any]            =				0
      __lowerCAmelCase:       str            =				self.font_size
      __lowerCAmelCase:       Optional[Any]            =				np.maximum(list(mplc.to_rgb(UpperCAmelCase ) )      ,  0.2 )
      __lowerCAmelCase:       Any            =				max(0.8      ,  np.max(UpperCAmelCase ) )
      __lowerCAmelCase:       Any            =				{
          'facecolor': 'black',
          'alpha': self.alpha,
          'pad': self.pad,
          'edgecolor': 'none',
      }
      __lowerCAmelCase     ,							__lowerCAmelCase:       Any            =				position
      self.ax.text(
          UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  size=font_size * self.scale      ,  family='sans-serif'      ,  bbox=UpperCAmelCase      ,  verticalalignment='top'      ,  horizontalalignment=UpperCAmelCase      ,  color=UpperCAmelCase      ,  zorder=1_0      ,  rotation=UpperCAmelCase      ,  )


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		Tuple=None )							->     Any:
      if saveas is None:
       __lowerCAmelCase:       Dict            =				self.saveas
      if saveas.lower().endswith('.jpg' ) or saveas.lower().endswith('.png' ):
       cva.imwrite(
           UpperCAmelCase      ,  self._get_buffer()[:, :, ::-1]      ,  )
      else:
       self.fig.savefig(UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[str]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		Optional[Any] )							->     Optional[int]:
      __lowerCAmelCase:       Union[str, Any]            =				[self.idaobj[i] for i in classes]
      __lowerCAmelCase:       Dict            =				[self.idaattr[i] for i in attr_classes]
      __lowerCAmelCase:       Union[str, Any]            =				[
          F'''{label} {score:.2f} {attr} {attr_score:.2f}'''
          for label, score, attr, attr_score in zip(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )
      ]
      return labels


     def   UpperCAmelCase  (							self      :		Any      ,  UpperCAmelCase      :		Dict      ,  UpperCAmelCase      :		Union[str, Any] )							->     Dict:
      __lowerCAmelCase:       Optional[Any]            =				[self.idaobj[i] for i in classes]
      if scores is not None:
       if labels is None:
        __lowerCAmelCase:       Any            =				['{:.0f}%'.format(s * 1_0_0 ) for s in scores]
       else:
        __lowerCAmelCase:       List[str]            =				['{} {:.0f}%'.format(UpperCAmelCase      ,  s * 1_0_0 ) for li, s in zip(UpperCAmelCase      ,  UpperCAmelCase )]
      return labels


     def   UpperCAmelCase  (							self      :		Any      ,  UpperCAmelCase      :		str=2_5_5 )							->     Optional[Any]:
      __lowerCAmelCase:       str            =				np.random.randint(0      ,  len(_COLORS ) )
      __lowerCAmelCase:       str            =				_COLORS[idx] * maximum
      if not self.rgb:
       __lowerCAmelCase:       str            =				ret[::-1]
      return ret


     def   UpperCAmelCase  (							self      :		List[str] )							->     str:
      if not self.pynb:
       __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.canvas.print_to_buffer()
       if (width, height) != (self.width, self.height):
        __lowerCAmelCase:       int            =				cva.resize(self.img      ,  (width, height) )
       else:
        __lowerCAmelCase:       List[str]            =				self.img
      else:
       __lowerCAmelCase:       Union[str, Any]            =				io.BytesIO()  # works for cairo backend
       self.canvas.print_rgba(UpperCAmelCase )
       __lowerCAmelCase     ,							__lowerCAmelCase:       List[str]            =				self.width, self.height
       __lowerCAmelCase:       Optional[int]            =				buf.getvalue()
       __lowerCAmelCase:       Union[str, Any]            =				self.img

      __lowerCAmelCase:       Union[str, Any]            =				np.frombuffer(UpperCAmelCase      ,  dtype='uint8' )
      __lowerCAmelCase:       Optional[int]            =				buffer.reshape(UpperCAmelCase      ,  UpperCAmelCase      ,  4 )
      __lowerCAmelCase     ,							__lowerCAmelCase:       int            =				np.split(UpperCAmelCase      ,  [3]      ,  axis=2 )

      try:
       import numexpr as ne  # fuse them with numexpr

       __lowerCAmelCase:       List[str]            =				ne.evaluate('img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)' )
      except ImportError:
       __lowerCAmelCase:       Dict            =				alpha.astype('float32' ) / 255.0
       __lowerCAmelCase:       Any            =				img * (1 - alpha) + rgb * alpha

      return visualized_image.astype('uint8' )


     def   UpperCAmelCase  (							self      :		List[str]      ,  UpperCAmelCase      :		Optional[Any]      ,  UpperCAmelCase      :		Optional[int] )							->     Tuple:
      assert brightness_factor >= -1.0 and brightness_factor <= 1.0
      __lowerCAmelCase:       List[Any]            =				mplc.to_rgb(UpperCAmelCase )
      __lowerCAmelCase:       List[Any]            =				colorsys.rgb_to_hls(*mplc.to_rgb(UpperCAmelCase ) )
      __lowerCAmelCase:       List[str]            =				polygon_color[1] + (brightness_factor * polygon_color[1])
      __lowerCAmelCase:       Optional[int]            =				0.0 if modified_lightness < 0.0 else modified_lightness
      __lowerCAmelCase:       List[Any]            =				1.0 if modified_lightness > 1.0 else modified_lightness
      __lowerCAmelCase:       List[str]            =				colorsys.hls_to_rgb(polygon_color[0]      ,  UpperCAmelCase      ,  polygon_color[2] )
      return modified_color







_a			=       (
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)









import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
  from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import PoolFormerImageProcessor






class 							A_			(		snake_case__ ):


     def   UpperCAmelCase  (							self      :		int )							->     Tuple:
      __lowerCAmelCase:       Optional[Any]            =				self.config_class(**self.inputs_dict )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'hidden_sizes' ) )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'num_encoder_blocks' ) )







class 							A_			:


     def __init__(							self      :		Optional[int]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		List[str]=1_3      ,  UpperCAmelCase      :		Optional[Any]=6_4      ,  UpperCAmelCase      :		Union[str, Any]=3      ,  UpperCAmelCase      :		Optional[Any]=4      ,  UpperCAmelCase      :		Any=[2, 2, 2, 2]      ,  UpperCAmelCase      :		Optional[Any]=[8, 4, 2, 1]      ,  UpperCAmelCase      :		str=[1_6, 3_2, 6_4, 1_2_8]      ,  UpperCAmelCase      :		str=[1, 4, 8, 1_6]      ,  UpperCAmelCase      :		Optional[Any]=False      ,  UpperCAmelCase      :		str=True      ,  UpperCAmelCase      :		Optional[int]="gelu"      ,  UpperCAmelCase      :		Union[str, Any]=0.1      ,  UpperCAmelCase      :		Optional[Any]=0.02      ,  UpperCAmelCase      :		List[Any]=3      ,  UpperCAmelCase      :		Optional[int]=None      ,  )							->     Any:
      __lowerCAmelCase:       List[str]            =				parent
      __lowerCAmelCase:       Union[str, Any]            =				batch_size
      __lowerCAmelCase:       Union[str, Any]            =				image_size
      __lowerCAmelCase:       str            =				num_channels
      __lowerCAmelCase:       Tuple            =				num_encoder_blocks
      __lowerCAmelCase:       Optional[int]            =				sr_ratios
      __lowerCAmelCase:       Union[str, Any]            =				depths
      __lowerCAmelCase:       int            =				hidden_sizes
      __lowerCAmelCase:       List[Any]            =				downsampling_rates
      __lowerCAmelCase:       List[Any]            =				is_training
      __lowerCAmelCase:       Union[str, Any]            =				use_labels
      __lowerCAmelCase:       Union[str, Any]            =				hidden_act
      __lowerCAmelCase:       Any            =				hidden_dropout_prob
      __lowerCAmelCase:       List[Any]            =				initializer_range
      __lowerCAmelCase:       Dict            =				num_labels
      __lowerCAmelCase:       List[Any]            =				scope


     def   UpperCAmelCase  (							self      :		Optional[int] )							->     List[str]:
      __lowerCAmelCase:       Dict            =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

      __lowerCAmelCase:       str            =				None
      if self.use_labels:
       __lowerCAmelCase:       int            =				ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels )

      __lowerCAmelCase:       Dict            =				PoolFormerConfig(
          image_size=self.image_size      ,  num_channels=self.num_channels      ,  num_encoder_blocks=self.num_encoder_blocks      ,  depths=self.depths      ,  hidden_sizes=self.hidden_sizes      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  initializer_range=self.initializer_range      ,  )

      return config, pixel_values, labels


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		Tuple      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] )							->     str:
      __lowerCAmelCase:       Any            =				PoolFormerModel(config=UpperCAmelCase )
      model.to(UpperCAmelCase )
      model.eval()
      __lowerCAmelCase:       List[str]            =				model(UpperCAmelCase )
      __lowerCAmelCase:       Union[str, Any]            =				self.image_size // 32.0
      self.parent.assertEqual(
          result.last_hidden_state.shape      ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width) )


     def   UpperCAmelCase  (							self      :		Any )							->     int:
      __lowerCAmelCase:       List[str]            =				self.prepare_config_and_inputs()
      __lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				config_and_inputs
      __lowerCAmelCase:       List[str]            =				{'pixel_values': pixel_values}
      return config, inputs_dict







@require_torch
class 							A_			(		snake_case__							,     snake_case__							,     unittest.TestCase ):
     _lowercase      :					Optional[Any]       =     (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
     _lowercase      :					List[Any]       =     (
         {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
         if is_torch_available()
         else {}
     )

     _lowercase      :					Tuple       =     False
     _lowercase      :					Tuple       =     False
     _lowercase      :					List[Any]       =     False
     _lowercase      :					Any       =     False
     _lowercase      :					List[Any]       =     False


     def   UpperCAmelCase  (							self      :		str )							->     Any:
      __lowerCAmelCase:       int            =				PoolFormerModelTester(self )
      __lowerCAmelCase:       int            =				PoolFormerConfigTester(self      ,  config_class=UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      self.config_tester.run_common_tests()


     def   UpperCAmelCase  (							self      :		int )							->     int:
      __lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*UpperCAmelCase )


     @unittest.skip('PoolFormer does not use inputs_embeds' )
     def   UpperCAmelCase  (							self      :		Optional[int] )							->     Union[str, Any]:
      pass


     @unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods' )
     def   UpperCAmelCase  (							self      :		int )							->     List[str]:
      pass


     def   UpperCAmelCase  (							self      :		List[str] )							->     List[str]:
      def check_hidden_states_output(UpperCAmelCase      :		List[str]      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] ):
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.eval()

       with torch.no_grad():
        __lowerCAmelCase:       Dict            =				model(**self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase ) )

       __lowerCAmelCase:       int            =				outputs.hidden_states

       __lowerCAmelCase:       Optional[int]            =				self.model_tester.num_encoder_blocks
       self.assertEqual(len(UpperCAmelCase )      ,  UpperCAmelCase )

       # verify the first hidden states (first block)
       self.assertListEqual(
           list(hidden_states[0].shape[-3:] )      ,  [
               self.model_tester.hidden_sizes[0],
               self.model_tester.image_size // 4,
               self.model_tester.image_size // 4,
           ]      ,  )

      __lowerCAmelCase     ,							__lowerCAmelCase:       Dict            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Optional[int]            =				True
       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __lowerCAmelCase:       Optional[Any]            =				True

       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		List[Any] )							->     Optional[int]:
      if not self.model_tester.is_training:
       return

      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCAmelCase:       Optional[int]            =				True

      for model_class in self.all_model_classes:
       if model_class in get_values(UpperCAmelCase ):
        continue
       __lowerCAmelCase:       str            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.train()
       __lowerCAmelCase:       Any            =				self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase      ,  return_labels=UpperCAmelCase )
       __lowerCAmelCase:       str            =				model(**UpperCAmelCase ).loss
       loss.backward()


     def   UpperCAmelCase  (							self      :		Dict )							->     Tuple:
      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       __lowerCAmelCase:       Dict            =				inspect.signature(model.forward )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       __lowerCAmelCase:       List[str]            =				[*signature.parameters.keys()]

       __lowerCAmelCase:       List[Any]            =				['pixel_values']
       self.assertListEqual(arg_names[:1]      ,  UpperCAmelCase )


     @slow
     def   UpperCAmelCase  (							self      :		int )							->     str:
      for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCAmelCase:       List[str]            =				PoolFormerModel.from_pretrained(UpperCAmelCase )
       self.assertIsNotNone(UpperCAmelCase )







def _a			(	)   ->   Any:

 """simple docstring"""






 __lowerCAmelCase:       Optional[Any]            =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
 return image






@require_torch
class 							A_			(		unittest.TestCase ):


     @slow
     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      __lowerCAmelCase:       Optional[int]            =				PoolFormerImageProcessor()
      __lowerCAmelCase:       Any            =				PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12' ).to(UpperCAmelCase )

      __lowerCAmelCase:       int            =				image_processor(images=prepare_img()      ,  return_tensors='pt' ).to(UpperCAmelCase )

      # forward pass
      with torch.no_grad():
       __lowerCAmelCase:       List[Any]            =				model(**UpperCAmelCase )

      # verify the logits
      __lowerCAmelCase:       List[Any]            =				torch.Size((1, 1_0_0_0) )
      self.assertEqual(outputs.logits.shape      ,  UpperCAmelCase )

      __lowerCAmelCase:       Union[str, Any]            =				torch.tensor([-0.6113, 0.1685, -0.0492] ).to(UpperCAmelCase )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,  UpperCAmelCase      ,  atol=1E-4 ) )





