


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 ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


_lowercase       :      Optional[int]	=	logging.get_logger(__name__)

# General docstring
_lowercase       :      List[Any]	=	"ResNetConfig"

# Base docstring
_lowercase       :      Optional[int]	=	"microsoft/resnet-50"
_lowercase       :      int	=	[1, 2048, 7, 7]

# Image classification docstring
_lowercase       :      str	=	"microsoft/resnet-50"
_lowercase       :      int	=	"tiger cat"

_lowercase       :      Tuple	=	[
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







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

				def      _UpperCAmelCase					(						self				,   a__   )	->				Tensor:
					A								=				self.convolution(a__   )
					A								=				self.normalization(a__   )
					A								=				self.activation(a__   )
					return hidden_state






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__   )	->				Tuple:
					super().__init__()
					A								=				ResNetConvLayer(
					    config.num_channels				,   config.embedding_size				,   kernel_size=7				,   stride=2				,   activation=config.hidden_act   )
					A								=				nn.MaxPoolad(kernel_size=3				,   stride=2				,   padding=1   )
					A								=				config.num_channels

				def      _UpperCAmelCase					(						self				,   a__   )	->				Tensor:
					A								=				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."""   )
					A								=				self.embedder(a__   )
					A								=				self.pooler(a__   )
					return embedding






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__				,   a__ = 2   )	->				List[Any]:
					super().__init__()
					A								=				nn.Convad(a__				,   a__				,   kernel_size=1				,   stride=a__				,   bias=a__   )
					A								=				nn.BatchNormad(a__   )

				def      _UpperCAmelCase					(						self				,   a__   )	->				Tensor:
					A								=				self.convolution(a__   )
					A								=				self.normalization(a__   )
					return hidden_state






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__				,   a__ = 1				,   a__ = "relu"   )	->				Optional[int]:
					super().__init__()
					A								=				in_channels != out_channels or stride != 1
					A								=				(
					    ResNetShortCut(a__				,   a__				,   stride=a__   ) if should_apply_shortcut else nn.Identity()
					)
					A								=				nn.Sequential(
					    ResNetConvLayer(a__				,   a__				,   stride=a__   )				,   ResNetConvLayer(a__				,   a__				,   activation=a__   )				,   )
					A								=				ACTaFN[activation]

				def      _UpperCAmelCase					(						self				,   a__   )	->				Union[str, Any]:
					A								=				hidden_state
					A								=				self.layer(a__   )
					A								=				self.shortcut(a__   )
					hidden_state += residual
					A								=				self.activation(a__   )
					return hidden_state






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__				,   a__ = 1				,   a__ = "relu"				,   a__ = 4   )	->				List[str]:
					super().__init__()
					A								=				in_channels != out_channels or stride != 1
					A								=				out_channels // reduction
					A								=				(
					    ResNetShortCut(a__				,   a__				,   stride=a__   ) if should_apply_shortcut else nn.Identity()
					)
					A								=				nn.Sequential(
					    ResNetConvLayer(a__				,   a__				,   kernel_size=1   )				,   ResNetConvLayer(a__				,   a__				,   stride=a__   )				,   ResNetConvLayer(a__				,   a__				,   kernel_size=1				,   activation=a__   )				,   )
					A								=				ACTaFN[activation]

				def      _UpperCAmelCase					(						self				,   a__   )	->				Dict:
					A								=				hidden_state
					A								=				self.layer(a__   )
					A								=				self.shortcut(a__   )
					hidden_state += residual
					A								=				self.activation(a__   )
					return hidden_state






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__				,   a__				,   a__ = 2				,   a__ = 2				,   )	->				Tuple:
					super().__init__()

					A								=				ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

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

				def      _UpperCAmelCase					(						self				,   a__   )	->				Tensor:
					A								=				input
					for layer in self.layers:
						A								=				layer(a__   )
					return hidden_state






class       _UpperCamelCase    (					nn.Module				):

				"""simple docstring"""







				def __init__(						self				,   a__   )	->				str:
					super().__init__()
					A								=				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(
					    ResNetStage(
					        a__				,   config.embedding_size				,   config.hidden_sizes[0]				,   stride=2 if config.downsample_in_first_stage else 1				,   depth=config.depths[0]				,   )   )
					A								=				zip(config.hidden_sizes				,   config.hidden_sizes[1:]   )
					for (in_channels, out_channels), depth in zip(a__				,   config.depths[1:]   ):
						self.stages.append(ResNetStage(a__				,   a__				,   a__				,   depth=a__   )   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__ = False				,   a__ = True   )	->				BaseModelOutputWithNoAttention:
					A								=				() if output_hidden_states else None

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

						A								=				stage_module(a__   )

					if output_hidden_states:
						A								=				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=a__				,   hidden_states=a__				,   )






class       _UpperCamelCase    (					__snake_case				):

				"""simple docstring"""







				lowerCAmelCase 		= ResNetConfig
				lowerCAmelCase 		= 'resnet'
				lowerCAmelCase 		= 'pixel_values'
				lowerCAmelCase 		= True

				def      _UpperCAmelCase					(						self				,   a__   )	->				Union[str, Any]:
					if isinstance(a__				,   nn.Convad   ):
						nn.init.kaiming_normal_(module.weight				,   mode="""fan_out"""				,   nonlinearity="""relu"""   )
					elif isinstance(a__				,   (nn.BatchNormad, nn.GroupNorm)   ):
						nn.init.constant_(module.weight				,   1   )
						nn.init.constant_(module.bias				,   0   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__=False   )	->				Any:
					if isinstance(a__				,   a__   ):
						A								=				value
_lowercase       :      Union[str, Any]	=	R"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    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 ([`ResNetConfig`]): 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       :      List[Any]	=	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            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"






@add_start_docstrings(
    'The bare ResNet model outputting raw features without any specific head on top.'    ,		__snake_case    ,		)
class       _UpperCamelCase    (					__snake_case				):

				"""simple docstring"""







				def __init__(						self				,   a__   )	->				Any:
					super().__init__(a__   )
					A								=				config
					A								=				ResNetEmbeddings(a__   )
					A								=				ResNetEncoder(a__   )
					A								=				nn.AdaptiveAvgPoolad((1, 1)   )
					# Initialize weights and apply final processing
					self.post_init()

				@add_start_docstrings_to_model_forward(a__   )
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC				,   output_type=a__				,   config_class=_CONFIG_FOR_DOC				,   modality="""vision"""				,   expected_output=_EXPECTED_OUTPUT_SHAPE				,   )
				def      _UpperCAmelCase					(						self				,   a__				,   a__ = None				,   a__ = None   )	->				BaseModelOutputWithPoolingAndNoAttention:
					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

					A								=				self.embedder(a__   )

					A								=				self.encoder(
					    a__				,   output_hidden_states=a__				,   return_dict=a__   )

					A								=				encoder_outputs[0]

					A								=				self.pooler(a__   )

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

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






@add_start_docstrings(
    '\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '    ,		__snake_case    ,		)
class       _UpperCamelCase    (					__snake_case				):

				"""simple docstring"""







				def __init__(						self				,   a__   )	->				Optional[int]:
					super().__init__(a__   )
					A								=				config.num_labels
					A								=				ResNetModel(a__   )
					# classification head
					A								=				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(a__   )
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT				,   output_type=a__				,   config_class=_CONFIG_FOR_DOC				,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,   )
				def      _UpperCAmelCase					(						self				,   a__ = None				,   a__ = None				,   a__ = None				,   a__ = None				,   )	->				ImageClassifierOutputWithNoAttention:
					A								=				return_dict if return_dict is not None else self.config.use_return_dict

					A								=				self.resnet(a__				,   output_hidden_states=a__				,   return_dict=a__   )

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

					A								=				self.classifier(a__   )

					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(a__				,   a__   )
						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(a__				,   a__   )

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

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






@add_start_docstrings(
    '\n    ResNet backbone, to be used with frameworks like DETR and MaskFormer.\n    '    ,		__snake_case    ,		)
class       _UpperCamelCase    (					__snake_case    ,		__snake_case				):

				"""simple docstring"""







				def __init__(						self				,   a__   )	->				Optional[Any]:
					super().__init__(a__   )
					super()._init_backbone(a__   )

					A								=				[config.embedding_size] + config.hidden_sizes
					A								=				ResNetEmbeddings(a__   )
					A								=				ResNetEncoder(a__   )

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

				@add_start_docstrings_to_model_forward(a__   )
				@replace_return_docstrings(output_type=a__				,   config_class=_CONFIG_FOR_DOC   )
				def      _UpperCAmelCase					(						self				,   a__				,   a__ = None				,   a__ = None   )	->				BackboneOutput:
					A								=				return_dict if return_dict is not None else self.config.use_return_dict
					A								=				(
					    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
					)

					A								=				self.embedder(a__   )

					A								=				self.encoder(a__				,   output_hidden_states=a__				,   return_dict=a__   )

					A								=				outputs.hidden_states

					A								=				()
					for idx, stage in enumerate(self.stage_names   ):
						if stage in self.out_features:
							feature_maps += (hidden_states[idx],)

					if not return_dict:
						A								=				(feature_maps,)
						if output_hidden_states:
							output += (outputs.hidden_states,)
						return output

					return BackboneOutput(
					    feature_maps=a__				,   hidden_states=outputs.hidden_states if output_hidden_states else None				,   attentions=a__				,   )







import qiskit





def   _lowerCAmelCase				(   UpperCamelCase__:     int = 2						) ->   qiskit.result.counts.Counts:





	"""simple docstring"""







	A								=				qubits

	# Using Aer's simulator
	A								=				qiskit.Aer.get_backend("""aer_simulator"""						)

	# Creating a Quantum Circuit acting on the q register
	A								=				qiskit.QuantumCircuit(UpperCamelCase__							,					UpperCamelCase__						)

	# Adding a H gate on qubit 0 (now q0 in superposition)
	circuit.h(0						)

	for i in range(1							,					UpperCamelCase__						):
		# Adding CX (CNOT) gate
		circuit.cx(i - 1							,					UpperCamelCase__						)

	# Mapping the quantum measurement to the classical bits
	circuit.measure(list(range(UpperCamelCase__						)						)							,					list(range(UpperCamelCase__						)						)						)

	# Now measuring any one qubit would affect other qubits to collapse
	# their super position and have same state as the measured one.

	# Executing the circuit on the simulator
	A								=				qiskit.execute(UpperCamelCase__							,					UpperCamelCase__							,					shots=10_00						)

	return job.result().get_counts(UpperCamelCase__						)


if __name__ == "__main__":
				print(f'''Total count for various states are: {quantum_entanglement(3)}''')



