class_docstr: Constructs a ConvNeXT feature extractor.
  
  This feature extractor inherits from [`FeatureExtractionMixin`] which contains most of the main methods. Users
  should refer to this superclass for more information regarding those methods.
  
  Args:
      do_resize (`bool`, *optional*, defaults to `True`):
          Whether to resize (and optionally center crop) the input to a certain `size`.
      size (`int`, *optional*, defaults to 224):
          Resize the input to the given size. If 384 or larger, the image is resized to (`size`, `size`). Else, the
          smaller edge of the image will be matched to int(`size`/ `crop_pct`), after which the image is cropped to
          `size`. Only has an effect if `do_resize` is set to `True`.
      resample (`int`, *optional*, defaults to `PIL.Image.Resampling.BICUBIC`):
          An optional resampling filter. This can be one of `PIL.Image.Resampling.NEAREST`,
          `PIL.Image.Resampling.BOX`, `PIL.Image.Resampling.BILINEAR`, `PIL.Image.Resampling.HAMMING`,
          `PIL.Image.Resampling.BICUBIC` or `PIL.Image.Resampling.LANCZOS`. Only has an effect if `do_resize` is set
          to `True`.
      crop_pct (`float`, *optional*):
          The percentage of the image to crop. If `None`, then a cropping percentage of 224 / 256 is used. Only has
          an effect if `do_resize` is set to `True` and `size` < 384.
      do_normalize (`bool`, *optional*, defaults to `True`):
          Whether or not to normalize the input with mean and standard deviation.
      image_mean (`List[int]`, defaults to `[0.485, 0.456, 0.406]`):
          The sequence of means for each channel, to be used when normalizing images.
      image_std (`List[int]`, defaults to `[0.229, 0.224, 0.225]`):
          The sequence of standard deviations for each channel, to be used when normalizing images.
docstr: Main method to prepare for the model one or several image(s).
  
  <Tip warning={true}>
  
  NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
  PIL images.
  
  </Tip>
  
  Args:
      images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
          The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
          tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
          number of channels, H and W are image height and width.
  
      return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
          If set, will return tensors of a particular framework. Acceptable values are:
  
          - `'tf'`: Return TensorFlow `tf.constant` objects.
          - `'pt'`: Return PyTorch `torch.Tensor` objects.
          - `'np'`: Return NumPy `np.ndarray` objects.
          - `'jax'`: Return JAX `jnp.ndarray` objects.
  
  Returns:
      [`BatchFeature`]: A [`BatchFeature`] with the following fields:
  
      - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
        width).
code: def __call__(
      self,
      images: ImageInput,
      return_tensors: Optional[Union[str, TensorType]] = None,
      **kwargs,
  ) -> BatchFeature:
      """
      Main method to prepare for the model one or several image(s).
  
      <Tip warning={true}>
  
      NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
      PIL images.
  
      </Tip>
  
      Args:
          images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
              The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
              tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
              number of channels, H and W are image height and width.
  
          return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
              If set, will return tensors of a particular framework. Acceptable values are:
  
              - `'tf'`: Return TensorFlow `tf.constant` objects.
              - `'pt'`: Return PyTorch `torch.Tensor` objects.
              - `'np'`: Return NumPy `np.ndarray` objects.
              - `'jax'`: Return JAX `jnp.ndarray` objects.
  
      Returns:
          [`BatchFeature`]: A [`BatchFeature`] with the following fields:
  
          - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
            width).
      """
      # Input type checking for clearer error
      valid_images = False
  
      # Check that images has a valid type
      if isinstance(
          images, (Image.Image, np.ndarray)
      ) or is_torch_tensor(images):
          valid_images = True
      elif isinstance(images, (list, tuple)):
          if (
              len(images) == 0
              or isinstance(images[0], (Image.Image, np.ndarray))
              or is_torch_tensor(images[0])
          ):
              valid_images = True
  
      if not valid_images:
          raise ValueError(
              "Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), "
              "`List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples)."
          )
  
      is_batched = bool(
          isinstance(images, (list, tuple))
          and (
              isinstance(images[0], (Image.Image, np.ndarray))
              or is_torch_tensor(images[0])
          )
      )
  
      if not is_batched:
          images = [images]
  
      # transformations (resizing and optional center cropping + normalization)
      if self.do_resize and self.size is not None:
          if self.size >= 384:
              # warping (no cropping) when evaluated at 384 or larger
              images = [
                  self.resize(
                      image=image,
                      size=self.size,
                      resample=self.resample,
                  )
                  for image in images
              ]
          else:
              if self.crop_pct is None:
                  self.crop_pct = 224 / 256
              size = int(self.size / self.crop_pct)
              # to maintain same ratio w.r.t. 224 images
              images = [
                  self.resize(
                      image=image,
                      size=size,
                      default_to_square=False,
                      resample=self.resample,
                  )
                  for image in images
              ]
              images = [
                  self.center_crop(image=image, size=self.size)
                  for image in images
              ]
  
      if self.do_normalize:
          images = [
              self.normalize(
                  image=image, mean=self.image_mean, std=self.image_std
              )
              for image in images
          ]
  
      # return as BatchFeature
      data = {"pixel_values": images}
      encoded_inputs = BatchFeature(
          data=data, tensor_type=return_tensors
      )
  
      return encoded_inputs
  
file_path: H2O/h2o_flexgen/benchmark/third_party/transformers/src/transformers/models/convnext/feature_extraction_convnext.py
imports: from typing import Optional, Union
  import numpy
  from PIL import Image
  from transformers.image_utils import PILImageResampling
  from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
  from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
  from ...utils import TensorType, logging
label_desc: Use image node_id 2 for calling the ConvNextFeatureExtractor obj's underlying member method code with example usage: obj.__call__(images, return_tensors) and returns: encoded_inputs