


'''simple docstring'''






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


__UpperCAmelCase					       =							logging.get_logger(__name__)

__UpperCAmelCase					       =							{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

__UpperCAmelCase					       =							{
    '''vocab_file''': {
        '''squeezebert/squeezebert-uncased''': (
            '''https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt'''
        ),
        '''squeezebert/squeezebert-mnli''': '''https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt''',
        '''squeezebert/squeezebert-mnli-headless''': (
            '''https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''squeezebert/squeezebert-uncased''': (
            '''https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json'''
        ),
        '''squeezebert/squeezebert-mnli''': (
            '''https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json'''
        ),
        '''squeezebert/squeezebert-mnli-headless''': (
            '''https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json'''
        ),
    },
}

__UpperCAmelCase					       =							{
    '''squeezebert/squeezebert-uncased''': 512,
    '''squeezebert/squeezebert-mnli''': 512,
    '''squeezebert/squeezebert-mnli-headless''': 512,
}


__UpperCAmelCase					       =							{
    '''squeezebert/squeezebert-uncased''': {'''do_lower_case''': True},
    '''squeezebert/squeezebert-mnli''': {'''do_lower_case''': True},
    '''squeezebert/squeezebert-mnli-headless''': {'''do_lower_case''': True},
}




class 	a__       (							a__						):





							'''simple docstring'''






							lowercase__    :     Optional[int]					=   VOCAB_FILES_NAMES
							lowercase__    :     Tuple					=   PRETRAINED_VOCAB_FILES_MAP
							lowercase__    :     int					=   PRETRAINED_INIT_CONFIGURATION
							lowercase__    :     List[str]					=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase__    :     Tuple					=   SqueezeBertTokenizer







							def __init__(	self      ,					lowerCamelCase_=None      ,					lowerCamelCase_=None      ,					lowerCamelCase_=True      ,					lowerCamelCase_="[UNK]"      ,					lowerCamelCase_="[SEP]"      ,					lowerCamelCase_="[PAD]"      ,					lowerCamelCase_="[CLS]"      ,					lowerCamelCase_="[MASK]"      ,					lowerCamelCase_=True      ,					lowerCamelCase_=None      ,					**lowerCamelCase_      ,					) ->							Optional[Any]:
														super().__init__(
														    lowerCamelCase_      ,					tokenizer_file=lowerCamelCase_      ,					do_lower_case=lowerCamelCase_      ,					unk_token=lowerCamelCase_      ,					sep_token=lowerCamelCase_      ,					pad_token=lowerCamelCase_      ,					cls_token=lowerCamelCase_      ,					mask_token=lowerCamelCase_      ,					tokenize_chinese_chars=lowerCamelCase_      ,					strip_accents=lowerCamelCase_      ,					**lowerCamelCase_      ,					)

														lowerCAmelCase__      =			json.loads(self.backend_tokenizer.normalizer.__getstate__()     )
														if (
														    normalizer_state.get('''lowercase'''      ,					lowerCamelCase_     ) != do_lower_case
														    or normalizer_state.get('''strip_accents'''      ,					lowerCamelCase_     ) != strip_accents
														    or normalizer_state.get('''handle_chinese_chars'''      ,					lowerCamelCase_     ) != tokenize_chinese_chars
														):
																					lowerCAmelCase__      =			getattr(lowerCamelCase_      ,					normalizer_state.pop('''type'''     )     )
																					lowerCAmelCase__      =			do_lower_case
																					lowerCAmelCase__      =			strip_accents
																					lowerCAmelCase__      =			tokenize_chinese_chars
																					lowerCAmelCase__      =			normalizer_class(**lowerCamelCase_     )

														lowerCAmelCase__      =			do_lower_case







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_=None     ) ->							Union[str, Any]:
														lowerCAmelCase__      =			[self.cls_token_id] + token_ids_a + [self.sep_token_id]

														if token_ids_a:
																					output += token_ids_a + [self.sep_token_id]

														return output







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = None     ) ->							List[int]:
														lowerCAmelCase__      =			[self.sep_token_id]
														lowerCAmelCase__      =			[self.cls_token_id]
														if token_ids_a is None:
																					return len(cls + token_ids_a + sep     ) * [0]
														return len(cls + token_ids_a + sep     ) * [0] + len(token_ids_a + sep     ) * [1]







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = None     ) ->							Tuple[str]:
														lowerCAmelCase__      =			self._tokenizer.model.save(lowerCamelCase_      ,					name=lowerCamelCase_     )
														return tuple(lowerCamelCase_     )



'''simple docstring'''






from typing import Optional

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

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


__UpperCAmelCase					       =							logging.get_logger(__name__)

# General docstring
__UpperCAmelCase					       =							'''RegNetConfig'''

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

# Image classification docstring
__UpperCAmelCase					       =							'''facebook/regnet-y-040'''
__UpperCAmelCase					       =							'''tabby, tabby cat'''

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




class 	a__       (							nn.Module						):





							'''simple docstring'''






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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							Dict:
														lowerCAmelCase__      =			self.convolution(lowerCamelCase_     )
														lowerCAmelCase__      =			self.normalization(lowerCamelCase_     )
														lowerCAmelCase__      =			self.activation(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_     ) ->							Optional[Any]:
														super().__init__()
														lowerCAmelCase__      =			RegNetConvLayer(
														    config.num_channels      ,					config.embedding_size      ,					kernel_size=3      ,					stride=2      ,					activation=config.hidden_act     )
														lowerCAmelCase__      =			config.num_channels







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							int:
														lowerCAmelCase__      =			pixel_values.shape[1]
														if num_channels != self.num_channels:
																					raise ValueError(
																					    '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''     )
														lowerCAmelCase__      =			self.embedder(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_ = 2     ) ->							Any:
														super().__init__()
														lowerCAmelCase__      =			nn.Convad(lowerCamelCase_      ,					lowerCamelCase_      ,					kernel_size=1      ,					stride=lowerCamelCase_      ,					bias=lowerCamelCase_     )
														lowerCAmelCase__      =			nn.BatchNormad(lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							Tensor:
														lowerCAmelCase__      =			self.convolution(lowerCamelCase_     )
														lowerCAmelCase__      =			self.normalization(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_     ) ->							List[Any]:
														super().__init__()

														lowerCAmelCase__      =			nn.AdaptiveAvgPoolad((1, 1)     )
														lowerCAmelCase__      =			nn.Sequential(
														    nn.Convad(lowerCamelCase_      ,					lowerCamelCase_      ,					kernel_size=1     )      ,					nn.ReLU()      ,					nn.Convad(lowerCamelCase_      ,					lowerCamelCase_      ,					kernel_size=1     )      ,					nn.Sigmoid()      ,					)







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							int:
														# b c h w -> b c 1 1
														lowerCAmelCase__      =			self.pooler(lowerCamelCase_     )
														lowerCAmelCase__      =			self.attention(lowerCamelCase_     )
														lowerCAmelCase__      =			hidden_state * attention
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							List[str]:
														lowerCAmelCase__      =			hidden_state
														lowerCAmelCase__      =			self.layer(lowerCamelCase_     )
														lowerCAmelCase__      =			self.shortcut(lowerCamelCase_     )
														hidden_state += residual
														lowerCAmelCase__      =			self.activation(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							Union[str, Any]:
														lowerCAmelCase__      =			hidden_state
														lowerCAmelCase__      =			self.layer(lowerCamelCase_     )
														lowerCAmelCase__      =			self.shortcut(lowerCamelCase_     )
														hidden_state += residual
														lowerCAmelCase__      =			self.activation(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_ = 2      ,					lowerCamelCase_ = 2      ,					) ->							Dict:
														super().__init__()

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

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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							List[str]:
														lowerCAmelCase__      =			self.layers(lowerCamelCase_     )
														return hidden_state




class 	a__       (							nn.Module						):





							'''simple docstring'''






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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = False      ,					lowerCamelCase_ = True     ) ->							BaseModelOutputWithNoAttention:
														lowerCAmelCase__      =			() if output_hidden_states else None

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

																					lowerCAmelCase__      =			stage_module(lowerCamelCase_     )

														if output_hidden_states:
																					lowerCAmelCase__      =			hidden_states + (hidden_state,)

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

														return BaseModelOutputWithNoAttention(last_hidden_state=lowerCamelCase_      ,					hidden_states=lowerCamelCase_     )




class 	a__       (							a__						):





							'''simple docstring'''






							lowercase__    :     List[Any]					=   RegNetConfig
							lowercase__    :     Tuple					=   "regnet"
							lowercase__    :     List[str]					=   "pixel_values"
							lowercase__    :     Tuple					=   True







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							int:
														if isinstance(lowerCamelCase_      ,					nn.Convad     ):
																					nn.init.kaiming_normal_(module.weight      ,					mode='''fan_out'''      ,					nonlinearity='''relu'''     )
														elif isinstance(lowerCamelCase_      ,					(nn.BatchNormad, nn.GroupNorm)     ):
																					nn.init.constant_(module.weight      ,					1     )
																					nn.init.constant_(module.bias      ,					0     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_=False     ) ->							int:
														if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																					lowerCAmelCase__      =			value

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

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

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

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




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





							'''simple docstring'''






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







							@add_start_docstrings_to_model_forward(lowerCamelCase_     )
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC      ,					output_type=lowerCamelCase_      ,					config_class=_CONFIG_FOR_DOC      ,					modality='''vision'''      ,					expected_output=_EXPECTED_OUTPUT_SHAPE      ,					)
							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = None     ) ->							BaseModelOutputWithPoolingAndNoAttention:
														lowerCAmelCase__      =			(
														    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
														)
														lowerCAmelCase__      =			return_dict if return_dict is not None else self.config.use_return_dict

														lowerCAmelCase__      =			self.embedder(lowerCamelCase_     )

														lowerCAmelCase__      =			self.encoder(
														    lowerCamelCase_      ,					output_hidden_states=lowerCamelCase_      ,					return_dict=lowerCamelCase_     )

														lowerCAmelCase__      =			encoder_outputs[0]

														lowerCAmelCase__      =			self.pooler(lowerCamelCase_     )

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

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




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





							'''simple docstring'''






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







							@add_start_docstrings_to_model_forward(lowerCamelCase_     )
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT      ,					output_type=lowerCamelCase_      ,					config_class=_CONFIG_FOR_DOC      ,					expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,					)
							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = None      ,					) ->							ImageClassifierOutputWithNoAttention:
														lowerCAmelCase__      =			return_dict if return_dict is not None else self.config.use_return_dict

														lowerCAmelCase__      =			self.regnet(lowerCamelCase_      ,					output_hidden_states=lowerCamelCase_      ,					return_dict=lowerCamelCase_     )

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

														lowerCAmelCase__      =			self.classifier(lowerCamelCase_     )

														lowerCAmelCase__      =			None

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

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

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