docstr: labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
      Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
      config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
      `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
  
  Returns:
  
  Examples:
  
  ```python
  >>> from transformers import AutoImageProcessor, ImageGPTForImageClassification
  >>> from PIL import Image
  >>> import requests
  
  >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
  >>> image = Image.open(requests.get(url, stream=True).raw)
  
  >>> image_processor = AutoImageProcessor.from_pretrained("openai/imagegpt-small")
  >>> model = ImageGPTForImageClassification.from_pretrained("openai/imagegpt-small")
  
  >>> inputs = image_processor(images=image, return_tensors="pt")
  >>> outputs = model(**inputs)
  >>> logits = outputs.logits
  ```
docstr_tok: ["labels","(","`","torch.LongTensor","`","of","shape","`","(","batch_size",",",")","`",",","*","optional","*",")",":","Labels","for","computing","the","sequence","classification\/regression","loss",".","Indices","should","be","in","`","[","0",",","...",",","config.num_labels","-","1","]","`",".","If","`","config.num_labels","==","1","`","a","regression","loss","is","computed","(","Mean-Square","loss",")",",","If","`","config.num_labels",">","1","`","a","classification","loss","is","computed","(","Cross-Entropy",")",".","Returns",":","Examples",":","``","`","python",">",">",">","from","transformers","import","AutoImageProcessor",",","ImageGPTForImageClassification",">",">",">","from","PIL","import","Image",">",">",">","import","requests",">",">",">","url","=","``","http",":","\/\/images.cocodataset.org\/val2017\/000000039769.jpg","''",">",">",">","image","=","Image.open","(","requests.get","(","url",",","stream=True",")",".raw",")",">",">",">","image_processor","=","AutoImageProcessor.from_pretrained","(","``","openai\/imagegpt-small","''",")",">",">",">","model","=","ImageGPTForImageClassification.from_pretrained","(","``","openai\/imagegpt-small","''",")",">",">",">","inputs","=","image_processor","(","images=image",",","return_tensors=","''","pt","''",")",">",">",">","outputs","=","model","(","*","*","inputs",")",">",">",">","logits","=","outputs.logits","``","`"]
code: def forward(
      self,
      input_ids: Optional[torch.Tensor] = None,
      past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
      attention_mask: Optional[torch.Tensor] = None,
      token_type_ids: Optional[torch.Tensor] = None,
      position_ids: Optional[torch.Tensor] = None,
      head_mask: Optional[torch.Tensor] = None,
      inputs_embeds: Optional[torch.Tensor] = None,
      labels: Optional[torch.Tensor] = None,
      use_cache: Optional[bool] = None,
      output_attentions: Optional[bool] = None,
      output_hidden_states: Optional[bool] = None,
      return_dict: Optional[bool] = None,
      **kwargs: Any,
  ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
      r"""
      labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
          Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
          config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
          `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
  
      Returns:
  
      Examples:
  
      ```python
      >>> from transformers import AutoImageProcessor, ImageGPTForImageClassification
      >>> from PIL import Image
      >>> import requests
  
      >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
      >>> image = Image.open(requests.get(url, stream=True).raw)
  
      >>> image_processor = AutoImageProcessor.from_pretrained("openai/imagegpt-small")
      >>> model = ImageGPTForImageClassification.from_pretrained("openai/imagegpt-small")
  
      >>> inputs = image_processor(images=image, return_tensors="pt")
      >>> outputs = model(**inputs)
      >>> logits = outputs.logits
      ```"""
  
      if "pixel_values" in kwargs:
          warnings.warn(
              "The `pixel_values` argument is deprecated and will be removed in a future version, use `input_ids`"
              " instead.",
              FutureWarning,
          )
  
          if input_ids is not None:
              raise ValueError(
                  "You cannot pass both `pixel_values` and `input_ids`. Please make sure to only pass `input_ids`."
              )
  
          input_ids = kwargs.pop("pixel_values")
  
      return_dict = (
          return_dict
          if return_dict is not None
          else self.config.use_return_dict
      )
  
      transformer_outputs = self.transformer(
          input_ids,
          past_key_values=past_key_values,
          attention_mask=attention_mask,
          token_type_ids=token_type_ids,
          position_ids=position_ids,
          head_mask=head_mask,
          inputs_embeds=inputs_embeds,
          use_cache=use_cache,
          output_attentions=output_attentions,
          output_hidden_states=output_hidden_states,
          return_dict=return_dict,
      )
      hidden_states = transformer_outputs[0]
      # average-pool the hidden states along the sequence dimension
      pooled_hidden_states = hidden_states.mean(dim=1)
      # project from (batch_size, hidden_size) to (batch_size, num_labels)
      logits = self.score(pooled_hidden_states)
  
      loss = None
      if labels is not None:
          if self.config.problem_type is None:
              if self.num_labels == 1:
                  self.config.problem_type = "regression"
              elif self.num_labels > 1 and (
                  labels.dtype == torch.long
                  or labels.dtype == torch.int
              ):
                  self.config.problem_type = (
                      "single_label_classification"
                  )
              else:
                  self.config.problem_type = (
                      "multi_label_classification"
                  )
  
          if self.config.problem_type == "regression":
              loss_fct = MSELoss()
              if self.num_labels == 1:
                  loss = loss_fct(logits.squeeze(), labels.squeeze())
              else:
                  loss = loss_fct(logits, labels)
          elif (
              self.config.problem_type == "single_label_classification"
          ):
              loss_fct = CrossEntropyLoss()
              loss = loss_fct(
                  logits.view(-1, self.num_labels), labels.view(-1)
              )
          elif self.config.problem_type == "multi_label_classification":
              loss_fct = BCEWithLogitsLoss()
              loss = loss_fct(logits, labels)
      if not return_dict:
          output = (logits,) + transformer_outputs[1:]
          return ((loss,) + output) if loss is not None else output
  
      return SequenceClassifierOutputWithPast(
          loss=loss,
          logits=logits,
          past_key_values=transformer_outputs.past_key_values,
          hidden_states=transformer_outputs.hidden_states,
          attentions=transformer_outputs.attentions,
      )
  
imports: import math
  import os
  import warnings
  from typing import Any, Optional, Tuple, Union
  import torch
  import torch.utils.checkpoint
  from torch import nn
  from torch.cuda.amp import autocast
  from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
  from ...activations import ACT2FN
  from ...modeling_outputs import BaseModelOutputWithPastAndCrossAttentions, CausalLMOutputWithCrossAttentions, SequenceClassifierOutputWithPast
  from ...modeling_utils import PreTrainedModel
  from ...pytorch_utils import Conv1D, find_pruneable_heads_and_indices, prune_conv1d_layer
  from ...utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
  from .configuration_imagegpt import ImageGPTConfig
label_desc: Use image node_id 2 for calling the ImageGPTForImageClassification obj's underlying member method code with example usage: obj.forward(input_ids, past_key_values, attention_mask, token_type_ids, position_ids, head_mask, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict) and returns: SequenceClassifierOutputWithPast, unknown