informers 0.2.0 → 1.0.0

data/lib/informers/utils/hub.rb

@@ -0,0 +1,240 @@
+module Informers
+  module Utils
+    module Hub
+      class FileResponse
+        attr_reader :exists, :status
+
+        def initialize(file_path)
+          @file_path = file_path
+
+          @exists = File.exist?(file_path)
+          if @exists
+            @status = ["200", "OK"]
+          else
+            @status = ["404", "Not Found"]
+          end
+        end
+
+        def read
+          File.binread(@file_path)
+        end
+      end
+
+      def self.is_valid_url(string, protocols = nil, valid_hosts = nil)
+        begin
+          url = URI.parse(string)
+        rescue
+          return false
+        end
+        if protocols && !protocols.include?(url.scheme)
+          return false
+        end
+        if valid_hosts && !valid_hosts.include?(url.host)
+          return false
+        end
+        true
+      end
+
+      def self.get_file(url_or_path, progress_callback = nil, progress_info = {})
+        if !is_valid_url(url_or_path, ["http", "https"])
+          raise Error, "Invalid url"
+        else
+          headers = {}
+          headers["User-Agent"] = "informers/#{VERSION};"
+
+          # Check whether we are making a request to the Hugging Face Hub.
+          is_hfurl = is_valid_url(url_or_path, ["http", "https"], ["huggingface.co", "hf.co"])
+          if is_hfurl
+            # If an access token is present in the environment variables,
+            # we add it to the request headers.
+            token = ENV["HF_TOKEN"]
+            if token
+              headers["Authorization"] = "Bearer #{token}"
+            end
+          end
+          options = {}
+          if progress_callback
+            total_size = nil
+            options[:content_length_proc] = lambda do |size|
+              total_size = size
+              Utils.dispatch_callback(progress_callback, {status: "download"}.merge(progress_info).merge(total_size: size))
+            end
+            options[:progress_proc] = lambda do |size|
+              Utils.dispatch_callback(progress_callback, {status: "progress"}.merge(progress_info).merge(size: size, total_size: total_size))
+            end
+          end
+          URI.parse(url_or_path).open(**headers, **options)
+        end
+      end
+
+      class FileCache
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def match(request)
+          file_path = resolve_path(request)
+          file = FileResponse.new(file_path)
+
+          file if file.exists
+        end
+
+        def put(request, buffer)
+          output_path = resolve_path(request)
+
+          begin
+            FileUtils.mkdir_p(File.dirname(output_path))
+            File.binwrite(output_path, buffer)
+          rescue => e
+            warn "An error occurred while writing the file to cache: #{e}"
+          end
+        end
+
+        def resolve_path(request)
+          File.join(@path, request)
+        end
+      end
+
+      def self.try_cache(cache, *names)
+        names.each do |name|
+          begin
+            result = cache.match(name)
+            return result if result
+          rescue
+            next
+          end
+        end
+        nil
+      end
+
+      def self.get_model_file(path_or_repo_id, filename, fatal = true, **options)
+        # Initiate file retrieval
+        Utils.dispatch_callback(options[:progress_callback], {
+          status: "initiate",
+          name: path_or_repo_id,
+          file: filename
+        })
+
+        # If `cache_dir` is not specified, use the default cache directory
+        cache = FileCache.new(options[:cache_dir] || Informers.cache_dir)
+
+        revision = options[:revision] || "main"
+
+        request_url = path_join(path_or_repo_id, filename)
+
+        remote_url = path_join(
+          Informers.remote_host,
+          Informers.remote_path_template
+            .gsub("{model}", path_or_repo_id)
+            .gsub("{revision}", URI.encode_www_form_component(revision)),
+          filename
+        )
+
+        # Choose cache key for filesystem cache
+        # When using the main revision (default), we use the request URL as the cache key.
+        # If a specific revision is requested, we account for this in the cache key.
+        fs_cache_key = revision == "main" ? request_url : path_join(path_or_repo_id, revision, filename)
+
+        proposed_cache_key = fs_cache_key
+
+        resolved_path = cache.resolve_path(proposed_cache_key)
+
+        # Whether to cache the final response in the end.
+        to_cache_response = false
+
+        # A caching system is available, so we try to get the file from it.
+        response = try_cache(cache, proposed_cache_key)
+
+        cache_hit = !response.nil?
+
+        if response.nil?
+          # File is not cached, so we perform the request
+
+          if response.nil? || response.status[0] == "404"
+            # File not found locally. This means either:
+            # - The user has disabled local file access (`Informers.allow_local_models = false`)
+            # - the path is a valid HTTP url (`response.nil?`)
+            # - the path is not a valid HTTP url and the file is not present on the file system or local server (`response.status[0] == "404"`)
+
+            if options[:local_files_only] || !Informers.allow_remote_models
+              # User requested local files only, but the file is not found locally.
+              if fatal
+                raise Error, "`local_files_only: true` or `Informers.allow_remote_models = false` and file was not found locally at #{resolved_path.inspect}."
+              else
+                # File not found, but this file is optional.
+                # TODO in future, cache the response?
+                return nil
+              end
+            end
+
+            progress_info = {
+              name: path_or_repo_id,
+              file: filename
+            }
+
+            # File not found locally, so we try to download it from the remote server
+            response = get_file(remote_url, options[:progress_callback], progress_info)
+
+            if response.status[0] != "200"
+              # should not happen
+              raise Todo
+            end
+
+            # Success! We use the proposed cache key from earlier
+            cache_key = proposed_cache_key
+          end
+
+          to_cache_response = cache && !response.is_a?(FileResponse) && response.status[0] == "200"
+        end
+
+        buffer = response.read
+
+        if to_cache_response && cache_key && cache.match(cache_key).nil?
+          cache.put(cache_key, buffer)
+        end
+
+        Utils.dispatch_callback(options[:progress_callback], {
+          status: "done",
+          name: path_or_repo_id,
+          file: filename,
+          cache_hit: cache_hit
+        })
+
+        resolved_path
+      end
+
+      def self.get_model_json(model_path, file_name, fatal = true, **options)
+        buffer = get_model_file(model_path, file_name, fatal, **options)
+        if buffer.nil?
+          # Return empty object
+          return {}
+        end
+
+        JSON.load_file(buffer)
+      end
+
+      def self.path_join(*parts)
+        parts = parts.map.with_index do |part, index|
+          if index != 0
+            part = part.delete_prefix("/")
+          end
+          if index != parts.length - 1
+            part = part.delete_suffix("/")
+          end
+          part
+        end
+        parts.join("/")
+      end
+
+      def self.display_progress(filename, width, size, expected_size)
+        bar_width = width - (filename.length + 3)
+        progress = size / expected_size.to_f
+        done = (progress * bar_width).round
+        not_done = bar_width - done
+        "#{filename} |#{"█" * done}#{" " * not_done}|"
+      end
+    end
+  end
+end

data/lib/informers/utils/math.rb

@@ -0,0 +1,44 @@
+module Informers
+  module Utils
+    def self.softmax(arr)
+      # Compute the maximum value in the array
+      max_val = arr.max
+
+      #  Compute the exponentials of the array values
+      exps = arr.map { |x| Math.exp(x - max_val) }
+
+      # Compute the sum of the exponentials
+      sum_exps = exps.sum
+
+      # Compute the softmax values
+      softmax_arr = exps.map { |x| x / sum_exps }
+
+      softmax_arr
+    end
+
+    def self.sigmoid(arr)
+      arr.map { |v| 1 / (1 + Math.exp(-v)) }
+    end
+
+    def self.get_top_items(items, top_k = 0)
+      # if top == 0, return all
+
+      items = items
+        .map.with_index { |x, i| [i, x] } # Get indices ([index, score])
+        .sort_by { |v| -v[1] }            # Sort by log probabilities
+
+      if !top_k.nil? && top_k > 0
+        items = items.slice(0, top_k)     # Get top k items
+      end
+
+      items
+    end
+
+    def self.max(arr)
+      if arr.length == 0
+        raise Error, "Array must not be empty"
+      end
+      arr.map.with_index.max_by { |v, _| v }
+    end
+  end
+end

data/lib/informers/utils/tensor.rb

@@ -0,0 +1,26 @@
+module Informers
+  module Utils
+    def self.mean_pooling(last_hidden_state, attention_mask)
+      last_hidden_state.zip(attention_mask).map do |state, mask|
+        state[0].size.times.map do |k|
+          sum = 0.0
+          count = 0
+
+          state.zip(mask) do |s, m|
+            count += m
+            sum += s[k] * m
+          end
+
+          sum / count
+        end
+      end
+    end
+
+    def self.normalize(result)
+      result.map do |row|
+        norm = Math.sqrt(row.sum { |v| v * v })
+        row.map { |v| v / norm }
+      end
+    end
+  end
+end

data/lib/informers/version.rb

@@ -1,3 +1,3 @@
 module Informers
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/informers.rb

@@ -1,13 +1,32 @@
 # dependencies
-require "blingfire"
-require "numo/narray"
 require "onnxruntime"
+require "tokenizers"
+
+# stdlib
+require "io/console"
+require "json"
+require "open-uri"
+require "stringio"
+require "uri"
 
 # modules
-require "informers/feature_extraction"
-require "informers/fill_mask"
-require "informers/ner"
-require "informers/question_answering"
-require "informers/sentiment_analysis"
-require "informers/text_generation"
-require "informers/version"
+require_relative "informers/utils/core"
+require_relative "informers/utils/hub"
+require_relative "informers/utils/math"
+require_relative "informers/utils/tensor"
+require_relative "informers/configs"
+require_relative "informers/env"
+require_relative "informers/model"
+require_relative "informers/models"
+require_relative "informers/tokenizers"
+require_relative "informers/pipelines"
+
+module Informers
+  class Error < StandardError; end
+
+  class Todo < Error
+    def message
+      "not implemented yet"
+    end
+  end
+end

metadata

@@ -1,57 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: informers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-06 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: blingfire
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.7
-- !ruby/object:Gem::Dependency
-  name: numo-narray
+  name: onnxruntime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: onnxruntime
+  name: tokenizers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.2
 description:
 email: andrew@ankane.org
 executables: []
@@ -62,23 +48,17 @@ files:
 - LICENSE.txt
 - README.md
 - lib/informers.rb
-- lib/informers/feature_extraction.rb
-- lib/informers/fill_mask.rb
-- lib/informers/ner.rb
-- lib/informers/question_answering.rb
-- lib/informers/sentiment_analysis.rb
-- lib/informers/text_generation.rb
+- lib/informers/configs.rb
+- lib/informers/env.rb
+- lib/informers/model.rb
+- lib/informers/models.rb
+- lib/informers/pipelines.rb
+- lib/informers/tokenizers.rb
+- lib/informers/utils/core.rb
+- lib/informers/utils/hub.rb
+- lib/informers/utils/math.rb
+- lib/informers/utils/tensor.rb
 - lib/informers/version.rb
-- vendor/LICENSE-bert.txt
-- vendor/LICENSE-blingfire.txt
-- vendor/LICENSE-gpt2.txt
-- vendor/LICENSE-roberta.txt
-- vendor/bert_base_cased_tok.bin
-- vendor/bert_base_tok.bin
-- vendor/gpt2.bin
-- vendor/gpt2.i2w
-- vendor/roberta.bin
-- vendor/roberta.i2w
 homepage: https://github.com/ankane/informers
 licenses:
 - Apache-2.0
@@ -91,15 +71,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
-summary: State-of-the-art natural language processing for Ruby
+summary: Fast transformer inference for Ruby
 test_files: []

data/lib/informers/feature_extraction.rb

@@ -1,59 +0,0 @@
-# Copyright 2018 The HuggingFace Inc. team.
-# Copyright 2020 Andrew Kane.
-#
-# 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 Informers
-  class FeatureExtraction
-    def initialize(model_path)
-      tokenizer_path = File.expand_path("../../vendor/bert_base_cased_tok.bin", __dir__)
-      @tokenizer = BlingFire.load_model(tokenizer_path)
-      @model = OnnxRuntime::Model.new(model_path)
-    end
-
-    def predict(texts)
-      singular = !texts.is_a?(Array)
-      texts = [texts] if singular
-
-      # tokenize
-      input_ids =
-        texts.map do |text|
-          tokens = @tokenizer.text_to_ids(text, nil, 100) # unk token
-          tokens.unshift(101) # cls token
-          tokens << 102 # sep token
-          tokens
-        end
-
-      max_tokens = input_ids.map(&:size).max
-      attention_mask = []
-      input_ids.each do |ids|
-        zeros = [0] * (max_tokens - ids.size)
-
-        mask = ([1] * ids.size) + zeros
-        attention_mask << mask
-
-        ids.concat(zeros)
-      end
-
-      # infer
-      input = {
-        input_ids: input_ids,
-        attention_mask: attention_mask
-      }
-      output = @model.predict(input)
-      scores = output["output_0"] || output["last_hidden_state"]
-
-      singular ? scores.first : scores
-    end
-  end
-end

data/lib/informers/fill_mask.rb

@@ -1,109 +0,0 @@
-# Copyright 2018 The HuggingFace Inc. team.
-# Copyright 2021 Andrew Kane.
-#
-# 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 Informers
-  class FillMask
-    def initialize(model_path)
-      encoder_path = File.expand_path("../../vendor/roberta.bin", __dir__)
-      @encoder = BlingFire.load_model(encoder_path, prefix: false)
-
-      decoder_path = File.expand_path("../../vendor/roberta.i2w", __dir__)
-      @decoder = BlingFire.load_model(decoder_path)
-
-      @model = OnnxRuntime::Model.new(model_path)
-    end
-
-    def predict(texts)
-      singular = !texts.is_a?(Array)
-      texts = [texts] if singular
-
-      mask_token = 50264
-
-      # tokenize
-      input_ids =
-        texts.map do |text|
-          tokens = @encoder.text_to_ids(text, nil, 3) # unk token
-
-          # add mask token
-          mask_sequence = [28696, 43776, 15698]
-          masks = []
-          (tokens.size - 2).times do |i|
-            masks << i if tokens[i..(i + 2)] == mask_sequence
-          end
-          masks.reverse.each do |mask|
-            tokens = tokens[0...mask] + [mask_token] + tokens[(mask + 3)..-1]
-          end
-
-          tokens.unshift(0) # cls token
-          tokens << 2 # sep token
-
-          tokens
-        end
-
-      max_tokens = input_ids.map(&:size).max
-      attention_mask = []
-      input_ids.each do |ids|
-        zeros = [0] * (max_tokens - ids.size)
-
-        mask = ([1] * ids.size) + zeros
-        attention_mask << mask
-
-        ids.concat(zeros)
-      end
-
-      input = {
-        input_ids: input_ids,
-        attention_mask: attention_mask
-      }
-
-      masked_index = input_ids.map { |v| v.each_index.select { |i| v[i] == mask_token } }
-      masked_index.each do |v|
-        raise "No mask_token (<mask>) found on the input" if v.size < 1
-        raise "More than one mask_token (<mask>) is not supported" if v.size > 1
-      end
-
-      res = @model.predict(input)
-      outputs = res["output_0"] || res["logits"]
-      batch_size = outputs.size
-
-      results = []
-      batch_size.times do |i|
-        result = []
-
-        logits = outputs[i][masked_index[i][0]]
-        values = logits.map { |v| Math.exp(v) }
-        sum = values.sum
-        probs = values.map { |v| v / sum }
-        res = probs.each_with_index.sort_by { |v| -v[0] }.first(5)
-
-        res.each do |(v, p)|
-          tokens = input[:input_ids][i].dup
-          tokens[masked_index[i][0]] = p
-          result << {
-            sequence: @decoder.ids_to_text(tokens),
-            score: v,
-            token: p,
-            # TODO figure out prefix space
-            token_str: @decoder.ids_to_text([p], skip_special_tokens: false)
-          }
-        end
-
-        results += [result]
-      end
-
-      singular ? results.first : results
-    end
-  end
-end