




"""simple docstring"""





# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase					,							UpperCamelCase					,							UpperCamelCase				)      ->      Optional[Any]:


			"""simple docstring"""
			__UpperCAmelCase						:			Any												=       multiprocessing.Manager()
			__UpperCAmelCase						:			Dict												=       manager.list()

			__UpperCAmelCase						:			Union[str, Any]												=       multiprocessing.Process(target=UpperCamelCase					,							args=(check_program, result, timeout)				)
			p.start()
			p.join(timeout=timeout + 1				)
			if p.is_alive():
						p.kill()

			if not result:
						result.append("timed out"				)

			return {
			    "task_id": task_id,
			    "passed": result[0] == "passed",
			    "result": result[0],
			    "completion_id": completion_id,
			}

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase					,							UpperCamelCase				)      ->      Any:


			"""simple docstring"""
			with create_tempdir():
						# These system calls are needed when cleaning up tempdir.
						import os
						import shutil

						__UpperCAmelCase						:			Dict												=       shutil.rmtree
						__UpperCAmelCase						:			Optional[Any]												=       os.rmdir
						__UpperCAmelCase						:			int												=       os.chdir

						# Disable functionalities that can make destructive changes to the test.
						reliability_guard()

						# Run program.
						try:
									__UpperCAmelCase						:			Any												=       {}
									with swallow_io():
												with time_limit(UpperCamelCase				):
															exec(UpperCamelCase					,							UpperCamelCase				)
									result.append("passed"				)
						except TimeoutException:
									result.append("timed out"				)
						except BaseException as e:
									result.append(f"failed: {e}"				)

						# Needed for cleaning up.
						__UpperCAmelCase						:			Union[str, Any]												=       rmtree
						__UpperCAmelCase						:			Union[str, Any]												=       rmdir
						__UpperCAmelCase						:			int												=       chdir

@contextlib.contextmanager
def        _UpperCamelCase     (      UpperCamelCase				)      ->      str:


			"""simple docstring"""
			def signal_handler(UpperCamelCase					,							UpperCamelCase				):
						raise TimeoutException("Timed out!"				)

			signal.setitimer(signal.ITIMER_REAL					,							UpperCamelCase				)
			signal.signal(signal.SIGALRM					,							UpperCamelCase				)
			try:
						yield
			finally:
						signal.setitimer(signal.ITIMER_REAL					,							0				)

@contextlib.contextmanager
def        _UpperCamelCase     (      )      ->      Optional[Any]:


			"""simple docstring"""
			__UpperCAmelCase						:			List[Any]												=       WriteOnlyStringIO()
			with contextlib.redirect_stdout(UpperCamelCase				):
						with contextlib.redirect_stderr(UpperCamelCase				):
									with redirect_stdin(UpperCamelCase				):
												yield

@contextlib.contextmanager
def        _UpperCamelCase     (      )      ->      int:


			"""simple docstring"""
			with tempfile.TemporaryDirectory() as dirname:
						with chdir(UpperCamelCase				):
									yield dirname



class   a__					(						__magic_name__ ):
			pass






class   a__					(						io.StringIO ):


			def    a_  (   self   :     Union[str, Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						raise OSError


			def    a_  (   self   :     str   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						raise OSError


			def    a_  (   self   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						raise OSError


			def    a_  (   self   :     Optional[int]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						return False






class   a__					(						contextlib._RedirectStream ):  # type: ignore
			lowercase_		=						"stdin"






@contextlib.contextmanager
def        _UpperCamelCase     (      UpperCamelCase				)      ->      Dict:


			"""simple docstring"""
			if root == ".":
						yield
						return
			__UpperCAmelCase						:			Tuple												=       os.getcwd()
			os.chdir(UpperCamelCase				)
			try:
						yield
			except BaseException as exc:
						raise exc
			finally:
						os.chdir(UpperCamelCase				)





def        _UpperCamelCase     (      UpperCamelCase=None				)      ->      int:


			"""simple docstring"""

			if maximum_memory_bytes is not None:
						import resource

						resource.setrlimit(resource.RLIMIT_AS					,							(maximum_memory_bytes, maximum_memory_bytes)				)
						resource.setrlimit(resource.RLIMIT_DATA					,							(maximum_memory_bytes, maximum_memory_bytes)				)
						if not platform.uname().system == "Darwin":
									resource.setrlimit(resource.RLIMIT_STACK					,							(maximum_memory_bytes, maximum_memory_bytes)				)

			faulthandler.disable()

			import builtins

			__UpperCAmelCase						:			Any												=       None
			__UpperCAmelCase						:			int												=       None

			import os

			__UpperCAmelCase						:			Tuple												=       "1"

			__UpperCAmelCase						:			List[Any]												=       None
			__UpperCAmelCase						:			List[Any]												=       None
			__UpperCAmelCase						:			Optional[int]												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			Tuple												=       None
			__UpperCAmelCase						:			List[str]												=       None
			__UpperCAmelCase						:			Any												=       None
			__UpperCAmelCase						:			Optional[int]												=       None
			__UpperCAmelCase						:			Tuple												=       None
			__UpperCAmelCase						:			Any												=       None
			__UpperCAmelCase						:			List[str]												=       None
			__UpperCAmelCase						:			Optional[Any]												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			Optional[Any]												=       None
			__UpperCAmelCase						:			Optional[int]												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			Any												=       None
			__UpperCAmelCase						:			Optional[int]												=       None
			__UpperCAmelCase						:			Optional[Any]												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			str												=       None
			__UpperCAmelCase						:			List[str]												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			Tuple												=       None
			__UpperCAmelCase						:			Dict												=       None
			__UpperCAmelCase						:			int												=       None
			__UpperCAmelCase						:			Dict												=       None

			import shutil

			__UpperCAmelCase						:			str												=       None
			__UpperCAmelCase						:			Union[str, Any]												=       None
			__UpperCAmelCase						:			List[str]												=       None

			import subprocess

			__UpperCAmelCase						:			Optional[int]												=       None  # type: ignore

			__UpperCAmelCase						:			str												=       None

			import sys

			__UpperCAmelCase						:			Optional[Any]												=       None
			__UpperCAmelCase						:			List[Any]												=       None
			__UpperCAmelCase						:			Dict												=       None
			__UpperCAmelCase						:			Optional[int]												=       None
			__UpperCAmelCase						:			Optional[int]												=       None




'''simple docstring'''
import collections.abc
from typing import Optional, Tuple, Union

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

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_poolformer import PoolFormerConfig


lowercase__											=logging.get_logger(__name__)

# General docstring
lowercase__											='PoolFormerConfig'

# Base docstring
lowercase__											='sail/poolformer_s12'
lowercase__											=[1, 5_12, 7, 7]

# Image classification docstring
lowercase__											='sail/poolformer_s12'
lowercase__											='tabby, tabby cat'

lowercase__											=[
    'sail/poolformer_s12',
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
]






def      UpperCamelCase_				(      A__  ,      A__ = 0.0  ,      A__ = False						):
	if drop_prob == 0.0 or not training:
		return input
	a_      				=						1 - drop_prob
	a_      				=						(input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
	a_      				=						keep_prob + torch.rand(A__  ,      dtype=input.dtype  ,      device=input.device						)
	random_tensor.floor_()  # binarize
	a_      				=						input.div(A__						) * random_tensor
	return output







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase = None	):
				super().__init__()
				a_      				=						drop_prob




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return drop_path(UpperCAmelCase					,   self.drop_prob					,   self.training	)






			def 					lowerCAmelCase__					(       self	):
				return "p={}".format(self.drop_prob	)







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase=None	):
				super().__init__()
				a_      				=						patch_size if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (patch_size, patch_size)
				a_      				=						stride if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (stride, stride)
				a_      				=						padding if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (padding, padding)

				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   kernel_size=UpperCAmelCase					,   stride=UpperCAmelCase					,   padding=UpperCAmelCase	)
				a_      				=						norm_layer(UpperCAmelCase	) if norm_layer else nn.Identity()






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.projection(UpperCAmelCase	)
				a_      				=						self.norm(UpperCAmelCase	)
				return embeddings







class   a_ (      nn.GroupNorm					):




			def __init__(       self					,   UpperCAmelCase					,   **UpperCAmelCase	):
				super().__init__(1					,   UpperCAmelCase					,   **UpperCAmelCase	)







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.AvgPoolad(UpperCAmelCase					,   stride=1					,   padding=pool_size // 2					,   count_include_pad=UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return self.pool(UpperCAmelCase	) - hidden_states







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   1	)
				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   1	)
				a_      				=						PoolFormerDropPath(UpperCAmelCase	)
				if isinstance(config.hidden_act					,   UpperCAmelCase	):
					a_      				=						ACTaFN[config.hidden_act]
				else:
					a_      				=						config.hidden_act






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.conva(UpperCAmelCase	)
				a_      				=						self.act_fn(UpperCAmelCase	)
				a_      				=						self.drop(UpperCAmelCase	)
				a_      				=						self.conva(UpperCAmelCase	)
				a_      				=						self.drop(UpperCAmelCase	)

				return hidden_states







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						PoolFormerPooling(UpperCAmelCase	)
				a_      				=						PoolFormerOutput(UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	)
				a_      				=						PoolFormerGroupNorm(UpperCAmelCase	)
				a_      				=						PoolFormerGroupNorm(UpperCAmelCase	)

				# Useful for training neural nets
				a_      				=						PoolFormerDropPath(UpperCAmelCase	) if drop_path > 0.0 else nn.Identity()
				a_      				=						config.use_layer_scale
				if config.use_layer_scale:
					a_      				=						nn.Parameter(
					    config.layer_scale_init_value * torch.ones((UpperCAmelCase)	)					,   requires_grad=UpperCAmelCase	)
					a_      				=						nn.Parameter(
					    config.layer_scale_init_value * torch.ones((UpperCAmelCase)	)					,   requires_grad=UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				if self.use_layer_scale:
					a_      				=						self.pooling(self.before_norm(UpperCAmelCase	)	)
					a_      				=						self.layer_scale_a.unsqueeze(-1	).unsqueeze(-1	) * pooling_output
					# First residual connection
					a_      				=						hidden_states + self.drop_path(UpperCAmelCase	)
					a_      				=						()

					a_      				=						self.output(self.after_norm(UpperCAmelCase	)	)
					a_      				=						self.layer_scale_a.unsqueeze(-1	).unsqueeze(-1	) * layer_output
					# Second residual connection
					a_      				=						hidden_states + self.drop_path(UpperCAmelCase	)

					a_      				=						(output,) + outputs
					return outputs

				else:
					a_      				=						self.drop_path(self.pooling(self.before_norm(UpperCAmelCase	)	)	)
					# First residual connection
					a_      				=						pooling_output + hidden_states
					a_      				=						()

					# Second residual connection inside the PoolFormerOutput block
					a_      				=						self.drop_path(self.output(self.after_norm(UpperCAmelCase	)	)	)
					a_      				=						hidden_states + layer_output

					a_      				=						(output,) + outputs
					return outputs







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						config
				# stochastic depth decay rule
				a_      				=						[x.item() for x in torch.linspace(0					,   config.drop_path_rate					,   sum(config.depths	)	)]

				# patch embeddings
				a_      				=						[]
				for i in range(config.num_encoder_blocks	):
					embeddings.append(
					    PoolFormerEmbeddings(
					        patch_size=config.patch_sizes[i]					,   stride=config.strides[i]					,   padding=config.padding[i]					,   num_channels=config.num_channels if i == 0 else config.hidden_sizes[i - 1]					,   hidden_size=config.hidden_sizes[i]					,   )	)
				a_      				=						nn.ModuleList(UpperCAmelCase	)

				# Transformer blocks
				a_      				=						[]
				a_      				=						0
				for i in range(config.num_encoder_blocks	):
					# each block consists of layers
					a_      				=						[]
					if i != 0:
						cur += config.depths[i - 1]
					for j in range(config.depths[i]	):
						layers.append(
						    PoolFormerLayer(
						        UpperCAmelCase					,   num_channels=config.hidden_sizes[i]					,   pool_size=config.pool_size					,   hidden_size=config.hidden_sizes[i]					,   intermediate_size=int(config.hidden_sizes[i] * config.mlp_ratio	)					,   drop_path=dpr[cur + j]					,   )	)
					blocks.append(nn.ModuleList(UpperCAmelCase	)	)

				a_      				=						nn.ModuleList(UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase=False					,   UpperCAmelCase=True	):
				a_      				=						() if output_hidden_states else None

				a_      				=						pixel_values
				for idx, layers in enumerate(zip(self.patch_embeddings					,   self.block	)	):
					a_				,  a_      				=						layers
					# Get patch embeddings from hidden_states
					a_      				=						embedding_layer(UpperCAmelCase	)
					# Send the embeddings through the blocks
					for _, blk in enumerate(UpperCAmelCase	):
						a_      				=						blk(UpperCAmelCase	)
						a_      				=						layer_outputs[0]

					if output_hidden_states:
						a_      				=						all_hidden_states + (hidden_states,)

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

				return BaseModelOutputWithNoAttention(last_hidden_state=UpperCAmelCase					,   hidden_states=UpperCAmelCase	)







class   a_ (      UpperCamelCase__					):
			lowerCamelCase__	:			Union[str, Any]       =    PoolFormerConfig
			lowerCamelCase__	:			Optional[Any]       =    'poolformer'
			lowerCamelCase__	:			List[Any]       =    'pixel_values'
			lowerCamelCase__	:			int       =    True




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				if isinstance(UpperCAmelCase					,   (nn.Linear, nn.Convad)	):
					module.weight.data.normal_(mean=0.0					,   std=self.config.initializer_range	)
					if module.bias is not None:
						module.bias.data.zero_()
				elif isinstance(UpperCAmelCase					,   nn.LayerNorm	):
					module.bias.data.zero_()
					module.weight.data.fill_(1.0	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase=False	):
				if isinstance(UpperCAmelCase					,   UpperCAmelCase	):
					a_      				=						value







lowercase__											=r'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use\n    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`PoolFormerConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

lowercase__											=r'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`PoolFormerImageProcessor.__call__`] for details.\n'







@add_start_docstrings(
    'The bare PoolFormer Model transformer outputting raw hidden-states without any specific head on top.'		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config

				a_      				=						PoolFormerEncoder(UpperCAmelCase	)

				# Initialize weights and apply final processing
				self.post_init()




			def 					lowerCAmelCase__					(       self	):
				return self.embeddings.patch_embeddings






			@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 					lowerCAmelCase__					(       self					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   ):
				a_      				=						(
				    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
				)
				a_      				=						return_dict if return_dict is not None else self.config.use_return_dict

				if pixel_values is None:
					raise ValueError("""You have to specify pixel_values"""	)

				a_      				=						self.encoder(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   )
				a_      				=						encoder_outputs[0]

				if not return_dict:
					return (sequence_output, None) + encoder_outputs[1:]

				return BaseModelOutputWithNoAttention(
				    last_hidden_state=UpperCAmelCase					,   hidden_states=encoder_outputs.hidden_states					,   )







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.Linear(config.hidden_size					,   config.hidden_size	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.dense(UpperCAmelCase	)
				return output







@add_start_docstrings(
    '\n    PoolFormer Model transformer with an image classification head on top\n    '		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config.num_labels
				a_      				=						PoolFormerModel(UpperCAmelCase	)

				# Final norm
				a_      				=						PoolFormerGroupNorm(config.hidden_sizes[-1]	)
				# Classifier head
				a_      				=						(
				    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 					lowerCAmelCase__					(       self					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   ):
				a_      				=						return_dict if return_dict is not None else self.config.use_return_dict

				a_      				=						self.poolformer(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   )

				a_      				=						outputs[0]

				a_      				=						self.classifier(self.norm(UpperCAmelCase	).mean([-2, -1]	)	)

				a_      				=						None
				if labels is not None:
					if self.config.problem_type is None:
						if self.num_labels == 1:
							a_      				=						"""regression"""
						elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
							a_      				=						"""single_label_classification"""
						else:
							a_      				=						"""multi_label_classification"""

					if self.config.problem_type == "regression":
						a_      				=						MSELoss()
						if self.num_labels == 1:
							a_      				=						loss_fct(logits.squeeze()					,   labels.squeeze()	)
						else:
							a_      				=						loss_fct(UpperCAmelCase					,   UpperCAmelCase	)
					elif self.config.problem_type == "single_label_classification":
						a_      				=						CrossEntropyLoss()
						a_      				=						loss_fct(logits.view(-1					,   self.num_labels	)					,   labels.view(-1	)	)
					elif self.config.problem_type == "multi_label_classification":
						a_      				=						BCEWithLogitsLoss()
						a_      				=						loss_fct(UpperCAmelCase					,   UpperCAmelCase	)

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

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