transformers-rb 0.1.0

data/lib/transformers/hf_hub/utils/_errors.rb

@@ -0,0 +1,94 @@
+module Transformers
+  module HfHub
+    class HfHubHTTPError < Error
+      def initialize(message, response = nil)
+        super(message)
+      end
+    end
+
+    class RepositoryNotFoundError < HfHubHTTPError; end
+
+    class GatedRepoError < RepositoryNotFoundError; end
+
+    class DisabledRepoError < HfHubHTTPError; end
+
+    class RevisionNotFoundError < HfHubHTTPError; end
+
+    class EntryNotFoundError < HfHubHTTPError; end
+
+    class LocalEntryNotFoundError < EntryNotFoundError; end
+
+    class BadRequestError < HfHubHTTPError; end
+
+    class << self
+      def hf_raise_for_status(response, endpoint_name: nil)
+        begin
+          response.value unless response.is_a?(Net::HTTPRedirection)
+        rescue
+          error_code = response["X-Error-Code"]
+          error_message = response["X-Error-Message"]
+
+          if error_code == "RevisionNotFound"
+            message = "#{response.code} Client Error." + "\n\n" + "Revision Not Found for url: #{response.uri}."
+            raise RevisionNotFoundError.new(message, response)
+
+          elsif error_code == "EntryNotFound"
+            message = "#{response.code} Client Error." + "\n\n" + "Entry Not Found for url: #{response.uri}."
+            raise EntryNotFoundError.new(message, response)
+
+          elsif error_code == "GatedRepo"
+            message = (
+              "#{response.code} Client Error." + "\n\n" + "Cannot access gated repo for url #{response.uri}."
+            )
+            raise GatedRepoError.new(message, response)
+
+          elsif error_message == "Access to this resource is disabled."
+            message = (
+              "#{response.code} Client Error." +
+              "\n\n" +
+              "Cannot access repository for url #{response.uri}." +
+              "\n" +
+              "Access to this resource is disabled."
+            )
+            raise DisabledRepoError.new(message, response)
+
+          elsif error_code == "RepoNotFound"
+            # 401 is misleading as it is returned for:
+            #    - private and gated repos if user is not authenticated
+            #    - missing repos
+            # => for now, we process them as `RepoNotFound` anyway.
+            # See https://gist.github.com/Wauplin/46c27ad266b15998ce56a6603796f0b9
+            message = (
+              "#{response.code} Client Error." +
+              "\n\n" +
+              "Repository Not Found for url: #{response.uri}." +
+              "\nPlease make sure you specified the correct `repo_id` and" +
+              " `repo_type`.\nIf you are trying to access a private or gated repo," +
+              " make sure you are authenticated."
+            )
+            raise RepositoryNotFoundError.new(message, response)
+
+          elsif response.code.to_i == 400
+            message = (
+              !endpoint_name.nil? ? "\n\nBad request for #{endpoint_name} endpoint:" : "\n\nBad request:"
+            )
+            raise BadRequestError.new(message, response)
+
+          elsif response.code.to_i == 403
+            message = (
+              "\n\n{response.code} Forbidden: #{error_message}." +
+              "\nCannot access content at: #{response.uri}." +
+              "\nIf you are trying to create or update content, " +
+              "make sure you have a token with the `write` role."
+            )
+            raise HfHubHTTPError.new(message, response)
+          end
+
+          # Convert `HTTPError` into a `HfHubHTTPError` to display request information
+          # as well (request id and/or server error message)
+          raise HfHubHTTPError.new(e.to_s, response)
+        end
+      end
+    end
+  end
+end

data/lib/transformers/hf_hub/utils/_headers.rb

@@ -0,0 +1,109 @@
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# 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.
+
+module Transformers
+  module HfHub
+    class << self
+      def build_hf_headers(
+        token: nil,
+        is_write_action: false,
+        library_name: nil,
+        library_version: nil,
+        user_agent: nil,
+        headers: nil
+      )
+        # Get auth token to send
+        token_to_send = get_token_to_send(token)
+        _validate_token_to_send(token_to_send, is_write_action)
+
+        # Combine headers
+        hf_headers = {
+          "user-agent" => _http_user_agent(
+            library_name: library_name,
+            library_version: library_version,
+            user_agent: user_agent
+          )
+        }
+        if !token_to_send.nil?
+          hf_headers["authorization"] = "Bearer #{token_to_send}"
+        end
+        if headers
+          hf_headers.merge!(headers)
+        end
+        hf_headers
+      end
+
+      def get_token_to_send(token)
+        # Case token is explicitly provided
+        if token.is_a?(String)
+          return token
+        end
+
+        # Case token is explicitly forbidden
+        if token == false
+          return nil
+        end
+
+        # Token is not provided: we get it from local cache
+        cached_token = nil # get_token
+
+        # Case token is explicitly required
+        if token == true
+          if cached_token.nil?
+            raise LocalTokenNotFoundError,
+              "Token is required (`token: true`), but no token found. You" +
+              " need to provide a token or be logged in to Hugging Face with" +
+              " `huggingface-cli login` or `huggingface_hub.login`. See" +
+              " https://huggingface.co/settings/tokens."
+          end
+          return cached_token
+        end
+
+        # Case implicit use of the token is forbidden by env variable
+        if HF_HUB_DISABLE_IMPLICIT_TOKEN
+          return nil
+        end
+
+        # Otherwise: we use the cached token as the user has not explicitly forbidden it
+        cached_token
+      end
+
+      def _validate_token_to_send(token, is_write_action)
+        if is_write_action
+          if token.nil?
+            raise ArgumentError,
+              "Token is required (write-access action) but no token found. You need" +
+              " to provide a token or be logged in to Hugging Face with" +
+              " `huggingface-cli login` or `huggingface_hub.login`. See" +
+              " https://huggingface.co/settings/tokens."
+          end
+        end
+      end
+
+      def _http_user_agent(
+        library_name: nil,
+        library_version: nil,
+        user_agent: nil
+      )
+        if !library_name.nil?
+          ua = "#{library_name}/#{library_version}"
+        else
+          ua = "unknown/None"
+        end
+        ua += "; ruby/#{RUBY_VERSION.to_f}"
+        ua
+      end
+    end
+  end
+end

data/lib/transformers/image_processing_base.rb

@@ -0,0 +1,169 @@
+# Copyright 2020 The HuggingFace Inc. team.
+#
+# 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.
+
+module Transformers
+  class ImageProcessingMixin
+    def self.from_pretrained(
+      pretrained_model_name_or_path,
+      cache_dir: nil,
+      force_download: false,
+      local_files_only: false,
+      token: nil,
+      revision: "main",
+      **kwargs
+    )
+      kwargs[:cache_dir] = cache_dir
+      kwargs[:force_download] = force_download
+      kwargs[:local_files_only] = local_files_only
+      kwargs[:revision] = revision
+
+      if !token.nil?
+        kwargs[:token] = token
+      end
+
+      image_processor_dict, kwargs = get_image_processor_dict(pretrained_model_name_or_path, **kwargs)
+
+      from_dict(image_processor_dict, **kwargs)
+    end
+
+    def self.get_image_processor_dict(
+      pretrained_model_name_or_path, **kwargs
+    )
+      cache_dir = kwargs.delete(:cache_dir)
+      force_download = kwargs.delete(:force_download) { false }
+      resume_download = kwargs.delete(:resume_download)
+      proxies = kwargs.delete(:proxies)
+      token = kwargs.delete(:token)
+      _use_auth_token = kwargs.delete(:use_auth_token)
+      local_files_only = kwargs.delete(:local_files_only) { false }
+      revision = kwargs.delete(:revision)
+      subfolder = kwargs.delete(:subfolder) { "" }
+
+      from_pipeline = kwargs.delete(:_from_pipeline)
+      from_auto_class = kwargs.delete(:_from_auto) { false }
+
+      user_agent = {file_type: "image processor", from_auto_class: from_auto_class}
+      if !from_pipeline.nil?
+        user_agent[:using_pipeline] = from_pipeline
+      end
+
+      if Utils::Hub.is_offline_mode && !local_files_only
+        Transformers.logger.info("Offline mode: forcing local_files_only: true")
+        local_files_only = true
+      end
+
+      pretrained_model_name_or_path = pretrained_model_name_or_path.to_s
+      is_local = Dir.exist?(pretrained_model_name_or_path)
+      if Dir.exist?(pretrained_model_name_or_path)
+        image_processor_file = File.join(pretrained_model_name_or_path, IMAGE_PROCESSOR_NAME)
+      end
+      if File.exist?(pretrained_model_name_or_path)
+        resolved_image_processor_file = pretrained_model_name_or_path
+        is_local = true
+      elsif Utils::Hub.is_remote_url(pretrained_model_name_or_path)
+        raise Todo
+      else
+        image_processor_file = IMAGE_PROCESSOR_NAME
+        begin
+          # Load from local folder or from cache or download from model Hub and cache
+          resolved_image_processor_file = Utils::Hub.cached_file(
+            pretrained_model_name_or_path,
+            image_processor_file,
+            cache_dir: cache_dir,
+            force_download: force_download,
+            proxies: proxies,
+            resume_download: resume_download,
+            local_files_only: local_files_only,
+            token: token,
+            user_agent: user_agent,
+            revision: revision,
+            subfolder: subfolder
+          )
+        rescue EnvironmentError
+          # Raise any environment error raise by `cached_file`. It will have a helpful error message adapted to
+          # the original exception.
+          raise
+        rescue
+          # For any other exception, we throw a generic error.
+          raise EnvironmentError,
+            "Can't load image processor for '#{pretrained_model_name_or_path}'. If you were trying to load" +
+            " it from 'https://huggingface.co/models', make sure you don't have a local directory with the" +
+            " same name. Otherwise, make sure '#{pretrained_model_name_or_path}' is the correct path to a" +
+            " directory containing a #{IMAGE_PROCESSOR_NAME} file"
+        end
+      end
+
+      begin
+        image_processor_dict = JSON.load_file(resolved_image_processor_file).transform_keys(&:to_sym)
+      rescue JSON::ParserError
+        raise EnvironmentError,
+          "It looks like the config file at '#{resolved_image_processor_file}' is not a valid JSON file."
+      end
+
+      if is_local
+        Transformers.logger.info("loading configuration file #{resolved_image_processor_file}")
+      else
+        Transformers.logger.info(
+          "loading configuration file #{image_processor_file} from cache at #{resolved_image_processor_file}"
+        )
+      end
+
+      if !is_local
+        if image_processor_dict.include?("auto_map")
+          raise Todo
+        end
+        if image_processor_dict.include?("custom_pipelines")
+          raise Todo
+        end
+      end
+      [image_processor_dict, kwargs]
+    end
+
+    def self.from_dict(image_processor_dict, **kwargs)
+      image_processor_dict = image_processor_dict.dup
+      return_unused_kwargs = kwargs.delete(:return_unused_kwargs) { false }
+
+      # The `size` parameter is a dict and was previously an int or tuple in feature extractors.
+      # We set `size` here directly to the `image_processor_dict` so that it is converted to the appropriate
+      # dict within the image processor and isn't overwritten if `size` is passed in as a kwarg.
+      if kwargs.include?(:size) && image_processor_dict.include?(:size)
+        image_processor_dict[:size] = kwargs.delete(:size)
+      end
+      if kwargs.include?(:crop_size) && image_processor_dict.include?(:crop_size)
+        image_processor_dict[:crop_size] = kwargs.delete(:crop_size)
+      end
+
+      image_processor = new(**image_processor_dict)
+
+      # Update image_processor with kwargs if needed
+      to_remove = []
+      kwargs.each do |key, value|
+        if image_processor.instance_variable_defined?("@#{key}")
+          image_processor.instance_variable_set("@#{key}", value)
+          to_remove << key
+        end
+      end
+      to_remove.each do |key|
+        kwargs.delete(key)
+      end
+
+      Transformers.logger.info("Image processor #{image_processor}")
+      if return_unused_kwargs
+        [image_processor, kwargs]
+      else
+        image_processor
+      end
+    end
+  end
+end

data/lib/transformers/image_processing_utils.rb

@@ -0,0 +1,63 @@
+# Copyright 2022 The HuggingFace Inc. team.
+#
+# 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.
+
+module Transformers
+  class BaseImageProcessor < ImageProcessingMixin
+    def initialize(**kwargs)
+      super(**kwargs)
+    end
+
+    def call(images, **kwargs)
+      preprocess(images, **kwargs)
+    end
+
+    def preprocess(images, **kwargs)
+      raise NotImplementedError, "Each image processor must implement its own preprocess method"
+    end
+
+    def rescale(
+      image,
+      scale,
+      data_format: nil,
+      input_data_format: nil,
+      **kwargs
+    )
+      ImageTransforms.rescale(image, scale, data_format: data_format, input_data_format: input_data_format, **kwargs)
+    end
+
+    def normalize(
+      image,
+      mean,
+      std,
+      data_format: nil,
+      input_data_format: nil,
+      **kwargs
+    )
+      ImageTransforms.normalize(
+        image, mean, std, data_format: data_format, input_data_format: input_data_format, **kwargs
+      )
+    end
+  end
+
+  module ImageProcessingUtils
+    def self.get_size_dict(size)
+      if !size.is_a?(Hash)
+        size_dict = {height: size, width: size}
+      else
+        size_dict = size
+      end
+      size_dict
+    end
+  end
+end

data/lib/transformers/image_transforms.rb

@@ -0,0 +1,208 @@
+# Copyright 2022 The HuggingFace Inc. team.
+#
+# 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.
+
+module Transformers
+  module ImageTransforms
+    def self.to_channel_dimension_format(
+      image,
+      channel_dim,
+      input_channel_dim: nil
+    )
+      if !image.is_a?(Numo::NArray)
+        raise ArgumentError, "Input image must be of type Numo::NArray, got #{image.class.name}"
+      end
+
+      if input_channel_dim.nil?
+        input_channel_dim = infer_channel_dimension_format(image)
+      end
+
+      target_channel_dim = ChannelDimension.new(channel_dim).to_s
+      if input_channel_dim == target_channel_dim
+        return image
+      end
+
+      if target_channel_dim == ChannelDimension::FIRST
+        image = image.transpose(2, 0, 1)
+      elsif target_channel_dim == ChannelDimension::LAST
+        image = image.transpose(1, 2, 0)
+      else
+        raise ArgumentError, "Unsupported channel dimension format: #{channel_dim}"
+      end
+
+      image
+    end
+
+    def self.rescale(
+      image,
+      scale,
+      data_format: nil,
+      dtype: Numo::SFloat,
+      input_data_format: nil
+    )
+      if !image.is_a?(Numo::NArray)
+        raise ArgumentError, "Input image must be of type Numo::NArray, got #{image.class.name}"
+      end
+
+      rescaled_image = image * scale
+      if !data_format.nil?
+        rescaled_image = to_channel_dimension_format(rescaled_image, data_format, input_data_format)
+      end
+
+      rescaled_image = rescaled_image.cast_to(dtype)
+
+      rescaled_image
+    end
+
+    def self.resize(
+      image,
+      size,
+      resample: nil,
+      reducing_gap: nil,
+      data_format: nil,
+      return_numpy: true,
+      input_data_format: nil
+    )
+      resample = !resample.nil? ? resample : nil # PILImageResampling.BILINEAR
+
+      if size.length != 2
+        raise ArgumentError, "size must have 2 elements"
+      end
+
+      # For all transformations, we want to keep the same data format as the input image unless otherwise specified.
+      # The resized image from PIL will always have channels last, so find the input format first.
+      if input_data_format.nil?
+        input_data_format = ImageUtils.infer_channel_dimension_format(image)
+      end
+      data_format = data_format.nil? ? input_data_format : data_format
+
+      # To maintain backwards compatibility with the resizing done in previous image feature extractors, we use
+      # the pillow library to resize the image and then convert back to numpy
+      do_rescale = false
+      if !image.is_a?(Vips::Image)
+        do_rescale = _rescale_for_pil_conversion(image)
+        image = to_pil_image(image, do_rescale: do_rescale, input_data_format: input_data_format)
+      end
+      height, width = size
+      # TODO support resample
+      resized_image = image.thumbnail_image(width, height: height, size: :force)
+
+      if return_numpy
+        resized_image = ImageUtils.to_numo_array(resized_image)
+        # If the input image channel dimension was of size 1, then it is dropped when converting to a PIL image
+        # so we need to add it back if necessary.
+        resized_image = resized_image.ndim == 2 ? resized_image.expand_dims(-1) : resized_image
+        # The image is always in channels last format after converting from a PIL image
+        resized_image = to_channel_dimension_format(
+          resized_image, data_format, input_channel_dim: ChannelDimension::LAST
+        )
+        # If an image was rescaled to be in the range [0, 255] before converting to a PIL image, then we need to
+        # rescale it back to the original range.
+        resized_image = do_rescale ? rescale(resized_image, 1 / 255.0) : resized_image
+      end
+      resized_image
+    end
+
+    def self.normalize(
+      image,
+      mean,
+      std,
+      data_format: nil,
+      input_data_format: nil
+    )
+      if !image.is_a?(Numo::NArray)
+        raise ArgumentError, "image must be a numpy array"
+      end
+
+      if input_data_format.nil?
+        input_data_format = infer_channel_dimension_format(image)
+      end
+
+      channel_axis = ImageUtils.get_channel_dimension_axis(image, input_data_format: input_data_format)
+      num_channels = image.shape[channel_axis]
+
+      # We cast to float32 to avoid errors that can occur when subtracting uint8 values.
+      # We preserve the original dtype if it is a float type to prevent upcasting float16.
+      if !image.is_a?(Numo::SFloat) && !image.is_a?(Numo::DFloat)
+        image = image.cast_to(Numo::SFloat)
+      end
+
+      if mean.is_a?(Enumerable)
+        if mean.length != num_channels
+          raise ArgumentError, "mean must have #{num_channels} elements if it is an iterable, got #{mean.length}"
+        end
+      else
+        mean = [mean] * num_channels
+      end
+      mean = Numo::DFloat.cast(mean)
+
+      if std.is_a?(Enumerable)
+        if std.length != num_channels
+          raise ArgumentError, "std must have #{num_channels} elements if it is an iterable, got #{std.length}"
+        end
+      else
+        std = [std] * num_channels
+      end
+      std = Numo::DFloat.cast(std)
+
+      if input_data_format == ChannelDimension::LAST
+        image = (image - mean) / std
+      else
+        image = ((image.transpose - mean) / std).transpose
+      end
+
+      image = !data_format.nil? ? to_channel_dimension_format(image, data_format, input_data_format) : image
+      image
+    end
+
+    def self.to_pil_image(
+      image,
+      do_rescale: nil,
+      input_data_format: nil
+    )
+      if image.is_a?(Vips::Image)
+        return image
+      end
+
+      # Convert all tensors to numo arrays before converting to Vips image
+      if !image.is_a?(Numo::NArray)
+        raise ArgumentError, "Input image type not supported: #{image.class.name}"
+      end
+
+      # If the channel has been moved to first dim, we put it back at the end.
+      image = to_channel_dimension_format(image, ChannelDimension::LAST, input_channel_dim: input_data_format)
+
+      # If there is a single channel, we squeeze it, as otherwise PIL can't handle it.
+      # image = image.shape[-1] == 1 ? image.squeeze(-1) : image
+
+      # Rescale the image to be between 0 and 255 if needed.
+      do_rescale = do_rescale.nil? ? _rescale_for_pil_conversion(image) : do_rescale
+
+      if do_rescale
+        image = rescale(image, 255)
+      end
+
+      image = image.cast_to(Numo::UInt8)
+      Vips::Image.new_from_memory(image.to_binary, image.shape[1], image.shape[0], image.shape[2], :uchar)
+    end
+
+    def self._rescale_for_pil_conversion(image)
+      if image.is_a?(Numo::UInt8)
+        do_rescale = false
+      else
+        raise Todo
+      end
+      do_rescale
+    end
+  end
+end