FM / glpn

/usr/local/lib/python3.6/site-packages/transformers/models/glpn/

/usr/local/lib/python3.6/site-packages/transformers/models/glpn

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
configuration_glpn.py	6224	0644	edit dl rm
convert_glpn_to_pytorch.py	8574	0644	edit dl rm
feature_extraction_glpn.py	5939	0644	edit dl rm
modeling_glpn.py	31235	0644	edit dl rm
__init__.py	1937	0644	edit dl rm

Edit: /usr/local/lib/python3.6/site-packages/transformers/models/glpn/feature_extraction_glpn.py (5939B)

# coding=utf-8
# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Feature extractor class for GLPN."""

from typing import Optional, Union

import numpy as np
from PIL import Image

from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from ...image_utils import ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
from ...utils import TensorType, logging

logger = logging.get_logger(__name__)

class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin):
    r"""
    Constructs a GLPN 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 the input based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """

model_input_names = ["pixel_values"]

def __init__(self, do_resize=True, size_divisor=32, resample=Image.BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)

width, height = image.size
        new_h, new_w = height // size_divisor * size_divisor, width // size_divisor * size_divisor

image = self.resize(image, size=(new_w, new_h), resample=resample)

return image

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).

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 + rescaling)
        if self.do_resize and self.size_divisor is not None:
            images = [
                self._resize(image=image, size_divisor=self.size_divisor, resample=self.resample) for image in images
            ]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]

# return as BatchFeature
        data = {"pixel_values": images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)

return encoded_inputs

cmd: