
'''simple docstring'''
import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    BioGptForCausalLM,
		    BioGptForSequenceClassification,
		    BioGptForTokenClassification,
		    BioGptModel,
		    BioGptTokenizer,
		)
		from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST







class   a_ :




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase=13					,   UpperCAmelCase=7					,   UpperCAmelCase=True					,   UpperCAmelCase=True					,   UpperCAmelCase=False					,   UpperCAmelCase=True					,   UpperCAmelCase=99					,   UpperCAmelCase=32					,   UpperCAmelCase=5					,   UpperCAmelCase=4					,   UpperCAmelCase=37					,   UpperCAmelCase="gelu"					,   UpperCAmelCase=0.1					,   UpperCAmelCase=0.1					,   UpperCAmelCase=5_12					,   UpperCAmelCase=16					,   UpperCAmelCase=2					,   UpperCAmelCase=0.02					,   UpperCAmelCase=3					,   UpperCAmelCase=4					,   UpperCAmelCase=None					,   ):
				a_      				=						parent
				a_      				=						batch_size
				a_      				=						seq_length
				a_      				=						is_training
				a_      				=						use_input_mask
				a_      				=						use_token_type_ids
				a_      				=						use_labels
				a_      				=						vocab_size
				a_      				=						hidden_size
				a_      				=						num_hidden_layers
				a_      				=						num_attention_heads
				a_      				=						intermediate_size
				a_      				=						hidden_act
				a_      				=						hidden_dropout_prob
				a_      				=						attention_probs_dropout_prob
				a_      				=						max_position_embeddings
				a_      				=						type_vocab_size
				a_      				=						type_sequence_label_size
				a_      				=						initializer_range
				a_      				=						num_labels
				a_      				=						num_choices
				a_      				=						scope




			def 					lowerCAmelCase__					(       self	):
				a_      				=						ids_tensor([self.batch_size, self.seq_length]					,   self.vocab_size	)

				a_      				=						None
				if self.use_input_mask:
					a_      				=						random_attention_mask([self.batch_size, self.seq_length]	)

				a_      				=						None
				if self.use_token_type_ids:
					a_      				=						ids_tensor([self.batch_size, self.seq_length]					,   self.type_vocab_size	)

				a_      				=						None
				a_      				=						None
				a_      				=						None
				if self.use_labels:
					a_      				=						ids_tensor([self.batch_size]					,   self.type_sequence_label_size	)
					a_      				=						ids_tensor([self.batch_size, self.seq_length]					,   self.num_labels	)
					a_      				=						ids_tensor([self.batch_size]					,   self.num_choices	)

				a_      				=						self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




			def 					lowerCAmelCase__					(       self	):
				return BioGptConfig(
				    vocab_size=self.vocab_size					,   hidden_size=self.hidden_size					,   num_hidden_layers=self.num_hidden_layers					,   num_attention_heads=self.num_attention_heads					,   intermediate_size=self.intermediate_size					,   hidden_act=self.hidden_act					,   hidden_dropout_prob=self.hidden_dropout_prob					,   attention_probs_dropout_prob=self.attention_probs_dropout_prob					,   max_position_embeddings=self.max_position_embeddings					,   type_vocab_size=self.type_vocab_size					,   is_decoder=UpperCAmelCase					,   initializer_range=self.initializer_range					,   )




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				a_      				=						BioGptModel(config=UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase	)
				a_      				=						model(UpperCAmelCase	)
				self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   ):
				a_      				=						BioGptForCausalLM(config=UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   token_type_ids=UpperCAmelCase					,   labels=UpperCAmelCase	)
				self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   *UpperCAmelCase	):
				a_      				=						BioGptModel(config=UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()

				# create attention mask
				a_      				=						torch.ones(input_ids.shape					,   dtype=torch.long					,   device=UpperCAmelCase	)
				a_      				=						self.seq_length // 2
				a_      				=						0

				# first forward pass
				a_				,  a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase	).to_tuple()

				# create hypothetical next token and extent to next_input_ids
				a_      				=						ids_tensor((self.batch_size, 1)					,   config.vocab_size	)

				# change a random masked slice from input_ids
				a_      				=						ids_tensor((1,)					,   UpperCAmelCase	).item() + 1
				a_      				=						ids_tensor((self.batch_size, 1)					,   config.vocab_size	).squeeze(-1	)
				a_      				=						random_other_next_tokens

				# append to next input_ids and attn_mask
				a_      				=						torch.cat([input_ids, next_tokens]					,   dim=-1	)
				a_      				=						torch.cat(
				    [attn_mask, torch.ones((attn_mask.shape[0], 1)					,   dtype=torch.long					,   device=UpperCAmelCase	)]					,   dim=1					,   )

				# get two different outputs
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase	)["""last_hidden_state"""]
				a_      				=						model(UpperCAmelCase					,   past_key_values=UpperCAmelCase					,   attention_mask=UpperCAmelCase	)["""last_hidden_state"""]

				# select random slice
				a_      				=						ids_tensor((1,)					,   output_from_past.shape[-1]	).item()
				a_      				=						output_from_no_past[:, -1, random_slice_idx].detach()
				a_      				=						output_from_past[:, 0, random_slice_idx].detach()

				# test that outputs are equal for slice
				self.parent.assertTrue(torch.allclose(UpperCAmelCase					,   UpperCAmelCase					,   atol=1e-3	)	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   *UpperCAmelCase	):
				a_      				=						BioGptModel(config=UpperCAmelCase	).to(UpperCAmelCase	).eval()

				a_      				=						torch.ones(input_ids.shape					,   dtype=torch.long					,   device=UpperCAmelCase	)

				# first forward pass
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   use_cache=UpperCAmelCase	)

				a_				,  a_      				=						outputs.to_tuple()

				# create hypothetical multiple next token and extent to next_input_ids
				a_      				=						ids_tensor((self.batch_size, 3)					,   config.vocab_size	)
				a_      				=						ids_tensor((self.batch_size, 3)					,   2	)

				# append to next input_ids and
				a_      				=						torch.cat([input_ids, next_tokens]					,   dim=-1	)
				a_      				=						torch.cat([attention_mask, next_attn_mask]					,   dim=-1	)

				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase	)["""last_hidden_state"""]
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   past_key_values=UpperCAmelCase	)[
				    """last_hidden_state"""
				]

				# select random slice
				a_      				=						ids_tensor((1,)					,   output_from_past.shape[-1]	).item()
				a_      				=						output_from_no_past[:, -3:, random_slice_idx].detach()
				a_      				=						output_from_past[:, :, random_slice_idx].detach()

				self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

				# test that outputs are equal for slice
				self.parent.assertTrue(torch.allclose(UpperCAmelCase					,   UpperCAmelCase					,   atol=1e-3	)	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   *UpperCAmelCase					,   UpperCAmelCase=False	):
				a_      				=						BioGptForCausalLM(UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				if gradient_checkpointing:
					model.gradient_checkpointing_enable()

				a_      				=						model(UpperCAmelCase					,   labels=UpperCAmelCase	)
				self.parent.assertEqual(result.loss.shape					,   ()	)
				self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)	)
				result.loss.backward()




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   *UpperCAmelCase	):
				a_      				=						BioGptModel(UpperCAmelCase	)
				a_      				=						model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers	)
				for key in model.state_dict().keys():
					if "c_proj" in key and "weight" in key:
						self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]	) - model_std	)					,   0.0_01	)
						self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]	) - 0.0	)					,   0.01	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   *UpperCAmelCase	):
				a_      				=						self.num_labels
				a_      				=						BioGptForTokenClassification(UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   token_type_ids=UpperCAmelCase	)
				self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.num_labels)	)






			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.prepare_config_and_inputs()
				(
				    (
				    a_
				)				,  (
				    a_
				)				,  (
				    a_
				)				,  (
				    a_
				)				,  (
				    a_
				)				,  (
				    a_
				)				,  (
				    a_
				)				,  
				)      				=						config_and_inputs
				a_      				=						{"""input_ids""": input_ids, """attention_mask""": input_mask}
				return config, inputs_dict







@require_torch
class   a_ (      UpperCamelCase__		,  UpperCamelCase__		,  UpperCamelCase__		,  unittest.TestCase					):
			lowerCamelCase__	:			Optional[int]       =    (
			    (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase__	:			Dict       =    (BioGptForCausalLM,) if is_torch_available() else ()
			lowerCamelCase__	:			int       =    (
			    {
			        'feature-extraction': BioGptModel,
			        'text-classification': BioGptForSequenceClassification,
			        'text-generation': BioGptForCausalLM,
			        'token-classification': BioGptForTokenClassification,
			        'zero-shot': BioGptForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			lowerCamelCase__	:			Union[str, Any]       =    False




			def 					lowerCAmelCase__					(       self	):
				a_      				=						BioGptModelTester(self	)
				a_      				=						ConfigTester(self					,   config_class=UpperCAmelCase					,   hidden_size=37	)




			def 					lowerCAmelCase__					(       self	):
				self.config_tester.run_common_tests()




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				for type in ["absolute", "relative_key", "relative_key_query"]:
					a_      				=						type
					self.model_tester.create_and_check_model(*UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_biogpt_model_attention_mask_past(*UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_forward_and_backwards(*UpperCAmelCase					,   gradient_checkpointing=UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_biogpt_model_past_large_inputs(*UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_biogpt_weight_initialization(*UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_biogpt_for_token_classification(*UpperCAmelCase	)




			@slow
			def 					lowerCAmelCase__					(       self	):
				a_      				=						BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""	)
				model.to(UpperCAmelCase	)
				a_      				=						BioGptTokenizer.from_pretrained("""microsoft/biogpt"""	)

				a_      				=						"""left"""

				# Define PAD Token = EOS Token = 50256
				a_      				=						tokenizer.eos_token
				a_      				=						model.config.eos_token_id

				# use different length sentences to test batching
				a_      				=						[
				    """Hello, my dog is a little""",
				    """Today, I""",
				]

				a_      				=						tokenizer(UpperCAmelCase					,   return_tensors="""pt"""					,   padding=UpperCAmelCase	)
				a_      				=						inputs["""input_ids"""].to(UpperCAmelCase	)

				a_      				=						model.generate(
				    input_ids=UpperCAmelCase					,   attention_mask=inputs["""attention_mask"""].to(UpperCAmelCase	)					,   )

				a_      				=						tokenizer(sentences[0]					,   return_tensors="""pt"""	).input_ids.to(UpperCAmelCase	)
				a_      				=						model.generate(input_ids=UpperCAmelCase	)

				a_      				=						inputs_non_padded.shape[-1] - inputs["""attention_mask"""][-1].long().sum().cpu().item()
				a_      				=						tokenizer(sentences[1]					,   return_tensors="""pt"""	).input_ids.to(UpperCAmelCase	)
				a_      				=						model.generate(input_ids=UpperCAmelCase					,   max_length=model.config.max_length - num_paddings	)

				a_      				=						tokenizer.batch_decode(UpperCAmelCase					,   skip_special_tokens=UpperCAmelCase	)
				a_      				=						tokenizer.decode(output_non_padded[0]					,   skip_special_tokens=UpperCAmelCase	)
				a_      				=						tokenizer.decode(output_padded[0]					,   skip_special_tokens=UpperCAmelCase	)

				a_      				=						[
				    """Hello, my dog is a little bit bigger than a little bit.""",
				    """Today, I have a good idea of how to use the information""",
				]
				self.assertListEqual(UpperCAmelCase					,   UpperCAmelCase	)
				self.assertListEqual(UpperCAmelCase					,   [non_padded_sentence, padded_sentence]	)




			@slow
			def 					lowerCAmelCase__					(       self	):
				for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					a_      				=						BioGptModel.from_pretrained(UpperCAmelCase	)
					self.assertIsNotNone(UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				a_				,  a_      				=						self.model_tester.prepare_config_and_inputs_for_common()
				a_      				=						3
				a_      				=						input_dict["""input_ids"""]
				a_      				=						input_ids.ne(1	).to(UpperCAmelCase	)
				a_      				=						ids_tensor([self.model_tester.batch_size]					,   self.model_tester.type_sequence_label_size	)
				a_      				=						BioGptForSequenceClassification(UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   labels=UpperCAmelCase	)
				self.assertEqual(result.logits.shape					,   (self.model_tester.batch_size, self.model_tester.num_labels)	)






			def 					lowerCAmelCase__					(       self	):
				a_				,  a_      				=						self.model_tester.prepare_config_and_inputs_for_common()
				a_      				=						3
				a_      				=						"""multi_label_classification"""
				a_      				=						input_dict["""input_ids"""]
				a_      				=						input_ids.ne(1	).to(UpperCAmelCase	)
				a_      				=						ids_tensor(
				    [self.model_tester.batch_size, config.num_labels]					,   self.model_tester.type_sequence_label_size	).to(torch.float	)
				a_      				=						BioGptForSequenceClassification(UpperCAmelCase	)
				model.to(UpperCAmelCase	)
				model.eval()
				a_      				=						model(UpperCAmelCase					,   attention_mask=UpperCAmelCase					,   labels=UpperCAmelCase	)
				self.assertEqual(result.logits.shape					,   (self.model_tester.batch_size, self.model_tester.num_labels)	)







@require_torch
class   a_ (      unittest.TestCase					):




			@slow
			def 					lowerCAmelCase__					(       self	):
				a_      				=						BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""	)
				a_      				=						torch.tensor([[2, 48_05, 9, 6_56, 21]]	)
				a_      				=						model(UpperCAmelCase	)[0]

				a_      				=						4_23_84

				a_      				=						torch.Size((1, 5, vocab_size)	)
				self.assertEqual(output.shape					,   UpperCAmelCase	)

				a_      				=						torch.tensor(
				    [[[-9.52_36, -9.89_18, 10.45_57], [-11.04_69, -9.64_23, 8.10_22], [-8.86_64, -7.88_26, 5.53_25]]]	)

				self.assertTrue(torch.allclose(output[:, :3, :3]					,   UpperCAmelCase					,   atol=1e-4	)	)






			@slow
			def 					lowerCAmelCase__					(       self	):
				a_      				=						BioGptTokenizer.from_pretrained("""microsoft/biogpt"""	)
				a_      				=						BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""	)
				model.to(UpperCAmelCase	)

				torch.manual_seed(0	)
				a_      				=						tokenizer("""COVID-19 is"""					,   return_tensors="""pt"""	).to(UpperCAmelCase	)
				a_      				=						model.generate(
				    **UpperCAmelCase					,   min_length=1_00					,   max_length=10_24					,   num_beams=5					,   early_stopping=UpperCAmelCase					,   )
				a_      				=						tokenizer.decode(output_ids[0]					,   skip_special_tokens=UpperCAmelCase	)

				a_      				=						(
				    """COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the"""
				    """ causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and"""
				    """ territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),"""
				    """ and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and"""
				    """ more than 800,000 deaths."""
				)
				self.assertEqual(UpperCAmelCase					,   UpperCAmelCase	)


'''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 ...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__											=logging.get_logger(__name__)

# General docstring
lowercase__											='ResNetConfig'

# Base docstring
lowercase__											='microsoft/resnet-50'
lowercase__											=[1, 20_48, 7, 7]

# Image classification docstring
lowercase__											='microsoft/resnet-50'
lowercase__											='tiger cat'

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







class   a_ (      nn.Module					):




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.convolution(UpperCAmelCase	)
				a_      				=						self.normalization(UpperCAmelCase	)
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				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 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				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(UpperCAmelCase	)
				a_      				=						self.pooler(UpperCAmelCase	)
				return embedding







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase = 2	):
				super().__init__()
				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   kernel_size=1					,   stride=UpperCAmelCase					,   bias=UpperCAmelCase	)
				a_      				=						nn.BatchNormad(UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.convolution(UpperCAmelCase	)
				a_      				=						self.normalization(UpperCAmelCase	)
				return hidden_state







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase = 1					,   UpperCAmelCase = "relu"	):
				super().__init__()
				a_      				=						in_channels != out_channels or stride != 1
				a_      				=						(
				    ResNetShortCut(UpperCAmelCase					,   UpperCAmelCase					,   stride=UpperCAmelCase	) if should_apply_shortcut else nn.Identity()
				)
				a_      				=						nn.Sequential(
				    ResNetConvLayer(UpperCAmelCase					,   UpperCAmelCase					,   stride=UpperCAmelCase	)					,   ResNetConvLayer(UpperCAmelCase					,   UpperCAmelCase					,   activation=UpperCAmelCase	)					,   )
				a_      				=						ACTaFN[activation]






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						hidden_state
				a_      				=						self.layer(UpperCAmelCase	)
				a_      				=						self.shortcut(UpperCAmelCase	)
				hidden_state += residual
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







class   a_ (      nn.Module					):




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						hidden_state
				a_      				=						self.layer(UpperCAmelCase	)
				a_      				=						self.shortcut(UpperCAmelCase	)
				hidden_state += residual
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase = 2					,   UpperCAmelCase = 2					,   ):
				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(UpperCAmelCase					,   UpperCAmelCase					,   stride=UpperCAmelCase					,   activation=config.hidden_act	)					,   *[layer(UpperCAmelCase					,   UpperCAmelCase					,   activation=config.hidden_act	) for _ in range(depth - 1	)]					,   )






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						input
				for layer in self.layers:
					a_      				=						layer(UpperCAmelCase	)
				return hidden_state







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				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(
				        UpperCAmelCase					,   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(UpperCAmelCase					,   config.depths[1:]	):
					self.stages.append(ResNetStage(UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   depth=UpperCAmelCase	)	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = False					,   UpperCAmelCase = True	):
				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(UpperCAmelCase	)

				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=UpperCAmelCase					,   hidden_states=UpperCAmelCase					,   )







class   a_ (      UpperCamelCase__					):
			lowerCamelCase__	:			List[Any]       =    ResNetConfig
			lowerCamelCase__	:			Dict       =    'resnet'
			lowerCamelCase__	:			Dict       =    'pixel_values'
			lowerCamelCase__	:			str       =    True




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				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 					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) 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__											=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.'		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config
				a_      				=						ResNetEmbeddings(UpperCAmelCase	)
				a_      				=						ResNetEncoder(UpperCAmelCase	)
				a_      				=						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 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   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

				a_      				=						self.embedder(UpperCAmelCase	)

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

				a_      				=						encoder_outputs[0]

				a_      				=						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(
    '\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    '		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config.num_labels
				a_      				=						ResNetModel(UpperCAmelCase	)
				# 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(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.resnet(UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase	)

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

				a_      				=						self.classifier(UpperCAmelCase	)

				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	)







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




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				super()._init_backbone(UpperCAmelCase	)

				a_      				=						[config.embedding_size] + config.hidden_sizes
				a_      				=						ResNetEmbeddings(UpperCAmelCase	)
				a_      				=						ResNetEncoder(UpperCAmelCase	)

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






			@add_start_docstrings_to_model_forward(UpperCAmelCase	)
			@replace_return_docstrings(output_type=UpperCAmelCase					,   config_class=_CONFIG_FOR_DOC	)
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = None					,   UpperCAmelCase = None	):
				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(UpperCAmelCase	)

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

				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=UpperCAmelCase					,   hidden_states=outputs.hidden_states if output_hidden_states else None					,   attentions=UpperCAmelCase					,   )
