torch-rb 0.3.4 → 0.4.1

data/lib/torch/native/dispatcher.rb

@@ -1,48 +0,0 @@
-# We use a generic interface for methods (*args, **options)
-# and this class to determine the C++ method to call
-#
-# This is needed since LibTorch uses function overloading,
-# which isn't available in Ruby or Python
-#
-# PyTorch uses this approach, but the parser/dispatcher is written in C++
-#
-# We could generate Ruby methods directly, but an advantage of this approach is
-# arguments and keyword arguments can be used interchangably like in Python,
-# making it easier to port code
-
-module Torch
-  module Native
-    module Dispatcher
-      class << self
-        def bind
-          functions = Generator.grouped_functions
-          bind_functions(::Torch, :define_singleton_method, functions[:torch])
-          bind_functions(::Torch::Tensor, :define_method, functions[:tensor])
-          bind_functions(::Torch::NN, :define_singleton_method, functions[:nn])
-        end
-
-        def bind_functions(context, def_method, functions)
-          functions.group_by(&:ruby_name).sort_by { |g, _| g }.each do |name, funcs|
-            if def_method == :define_method
-              funcs.map! { |f| Function.new(f.function) }
-              funcs.each { |f| f.args.reject! { |a| a[:name] == "self" } }
-            end
-
-            defined = def_method == :define_method ? context.method_defined?(name) : context.respond_to?(name)
-            next if defined && name != "clone"
-
-            parser = Parser.new(funcs)
-
-            context.send(def_method, name) do |*args, **options|
-              result = parser.parse(args, options)
-              raise ArgumentError, result[:error] if result[:error]
-              send(result[:name], *result[:args])
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Torch::Native::Dispatcher.bind

data/lib/torch/native/function.rb

@@ -1,115 +0,0 @@
-module Torch
-  module Native
-    class Function
-      attr_reader :function, :tensor_options
-
-      def initialize(function)
-        @function = function
-
-        tensor_options_str = ", *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None)"
-        @tensor_options = @function["func"].include?(tensor_options_str)
-        @function["func"].sub!(tensor_options_str, ")")
-      end
-
-      def func
-        @func ||= @function["func"]
-      end
-
-      def name
-        @name ||= func.split("(", 2).first
-      end
-
-      def python_module
-        @python_module ||= @function["python_module"]
-      end
-
-      def variants
-        @variants ||= (@function["variants"] || "function").split(", ")
-      end
-
-      def args
-        @args ||= begin
-          args = []
-          pos = true
-          args_str = func.split("(", 2).last.split(") ->").first
-          args_str.split(", ").each do |a|
-            if a == "*"
-              pos = false
-              next
-            end
-            t, _, k = a.rpartition(" ")
-            k, d = k.split("=")
-            has_default = !d.nil?
-
-            if d
-              d =
-                case d
-                when "True"
-                  true
-                when "False"
-                  false
-                when "None"
-                  nil
-                when /\A\-?\d+\z/
-                  d.to_i
-                when "[]"
-                  []
-                when "[0,1]"
-                  [0, 1]
-                when /\A\de\-\d+\z/, /\A\d+\.\d+\z/
-                  d.to_f
-                when "Mean"
-                  "mean"
-                when "contiguous_format"
-                  d
-                when "long"
-                  :long
-                else
-                  raise "Unknown default: #{d}"
-                end
-            end
-
-            next if t == "Generator?"
-            next if t == "MemoryFormat"
-            next if t == "MemoryFormat?"
-            args << {name: k, type: t, default: d, pos: pos, has_default: has_default}
-          end
-          args
-        end
-      end
-
-      def out_size
-        @out_size ||= func.split("->").last.count("!")
-      end
-
-      def ret_size
-        @ret_size ||= func.split("->").last.split(", ").size
-      end
-
-      def out?
-        out_size > 0 && base_name[-1] != "_"
-      end
-
-      def ruby_name
-        @ruby_name ||= begin
-          name = base_name
-          if name.end_with?("_")
-            "#{name[0..-2]}!"
-          elsif name.start_with?("is_")
-            "#{name[3..-1]}?"
-          else
-            name
-          end
-        end
-      end
-
-      def cpp_name
-        @cpp_name ||= "_" + name.downcase.sub(".", "_")
-      end
-
-      def base_name
-        @base_name ||= name.split(".").first
-      end
-    end
-  end
-end

data/lib/torch/native/generator.rb

@@ -1,163 +0,0 @@
-require "yaml"
-# use require_relative for
-# rake generate:function (without bundle)
-require_relative "function"
-
-module Torch
-  module Native
-    module Generator
-      class << self
-        def generate_cpp_functions
-          functions = grouped_functions
-          generate_cpp_file("torch", :define_singleton_method, functions[:torch])
-          generate_cpp_file("tensor", :define_method, functions[:tensor])
-          generate_cpp_file("nn", :define_singleton_method, functions[:nn])
-        end
-
-        def grouped_functions
-          functions = functions()
-
-          # skip functions
-          skip_args = ["bool[3]", "Dimname", "Layout", "Storage", "ConstQuantizerPtr"]
-
-          # remove functions
-          functions.reject! do |f|
-            f.ruby_name.start_with?("_") ||
-            f.ruby_name.end_with?("_backward") ||
-            f.args.any? { |a| a[:type].include?("Dimname") }
-          end
-
-          # separate out into todo
-          todo_functions, functions =
-            functions.partition do |f|
-              f.args.any? do |a|
-                a[:type].include?("?") && !["Tensor?", "Generator?", "int?", "ScalarType?", "Tensor?[]"].include?(a[:type]) ||
-                skip_args.any? { |sa| a[:type].include?(sa) } ||
-                # call to 'range' is ambiguous
-                f.cpp_name == "_range" ||
-                # native_functions.yaml is missing size argument for normal
-                # https://pytorch.org/cppdocs/api/function_namespacetorch_1a80253fe5a3ded4716ec929a348adb4b9.html
-                (f.base_name == "normal" && !f.out?)
-              end
-            end
-
-          # todo_functions.each do |f|
-          #   puts f.func
-          #   puts
-          # end
-
-          nn_functions, other_functions = functions.partition { |f| f.python_module == "nn" }
-          torch_functions = other_functions.select { |f| f.variants.include?("function") }
-          tensor_functions = other_functions.select { |f| f.variants.include?("method") }
-
-          {torch: torch_functions, tensor: tensor_functions, nn: nn_functions}
-        end
-
-        private
-
-        def generate_cpp_file(type, def_method, functions)
-          hpp_template = <<-TEMPLATE
-// generated by rake generate:functions
-// do not edit by hand
-
-#pragma once
-
-void add_%{type}_functions(Module m);
-        TEMPLATE
-
-          cpp_template = <<-TEMPLATE
-// generated by rake generate:functions
-// do not edit by hand
-
-#include <torch/torch.h>
-#include <rice/Module.hpp>
-#include "templates.hpp"
-
-void add_%{type}_functions(Module m) {
-  m
-  %{functions};
-}
-        TEMPLATE
-
-          cpp_defs = []
-          functions.sort_by(&:cpp_name).each do |func|
-            fargs = func.args.dup #.select { |a| a[:type] != "Generator?" }
-            fargs << {name: "options", type: "TensorOptions"} if func.tensor_options
-
-            cpp_args = []
-            fargs.each do |a|
-              t =
-                case a[:type]
-                when "Tensor"
-                  "const Tensor &"
-                when "Tensor?"
-                  # TODO better signature
-                  "OptionalTensor"
-                when "ScalarType?"
-                  "torch::optional<ScalarType>"
-                when "Tensor[]"
-                  "TensorList"
-                when "Tensor?[]"
-                  # TODO make optional
-                  "TensorList"
-                when "int"
-                  "int64_t"
-                when "int?"
-                  "torch::optional<int64_t>"
-                when "float"
-                  "double"
-                when /\Aint\[/
-                  "IntArrayRef"
-                when /Tensor\(\S!?\)/
-                  "Tensor &"
-                when "str"
-                  "std::string"
-                when "TensorOptions"
-                  "const torch::TensorOptions &"
-                else
-                  a[:type]
-                end
-
-              t = "MyReduction" if a[:name] == "reduction" && t == "int64_t"
-              cpp_args << [t, a[:name]].join(" ").sub("& ", "&")
-            end
-
-            dispatch = func.out? ? "#{func.base_name}_out" : func.base_name
-            args = fargs.map { |a| a[:name] }
-            args.unshift(*args.pop(func.out_size)) if func.out?
-            args.delete("self") if def_method == :define_method
-
-            prefix = def_method == :define_method ? "self." : "torch::"
-
-            body = "#{prefix}#{dispatch}(#{args.join(", ")})"
-            # TODO check type as well
-            if func.ret_size > 1
-              body = "wrap(#{body})"
-            end
-
-            cpp_defs << ".#{def_method}(
-    \"#{func.cpp_name}\",
-    *[](#{cpp_args.join(", ")}) {
-      return #{body};
-    })"
-          end
-
-          hpp_contents = hpp_template % {type: type}
-          cpp_contents = cpp_template % {type: type, functions: cpp_defs.join("\n  ")}
-
-          path = File.expand_path("../../../ext/torch", __dir__)
-          File.write("#{path}/#{type}_functions.hpp", hpp_contents)
-          File.write("#{path}/#{type}_functions.cpp", cpp_contents)
-        end
-
-        def functions
-          @native_functions ||= YAML.load_file(path).map { |f| Function.new(f) }
-        end
-
-        def path
-          File.expand_path("native_functions.yaml", __dir__)
-        end
-      end
-    end
-  end
-end

data/lib/torch/native/parser.rb

@@ -1,140 +0,0 @@
-module Torch
-  module Native
-    class Parser
-      def initialize(functions)
-        @functions = functions
-        @name = @functions.first.ruby_name
-        @min_args = @functions.map { |f| f.args.count { |a| a[:pos] && !a[:has_default] } }.min
-        @max_args = @functions.map { |f| f.args.count { |a| a[:pos] } }.max
-      end
-
-      def parse(args, options)
-        candidates = @functions.dup
-
-        # remove nil
-        while args.any? && args.last.nil?
-          args.pop
-        end
-
-        # TODO account for args passed as options here
-        if args.size < @min_args || args.size > @max_args
-          expected = String.new(@min_args.to_s)
-          expected += "..#{@max_args}" if @max_args != @min_args
-          return {error: "wrong number of arguments (given #{args.size}, expected #{expected})"}
-        end
-
-        candidates.reject! { |f| args.size > f.args.size }
-
-        # exclude functions missing required options
-        candidates.reject! do |func|
-          # TODO make more generic
-          func.out? && !options[:out]
-        end
-
-        # handle out with multiple
-        # there should only be one match, so safe to modify all
-        out_func = candidates.find { |f| f.out? }
-        if out_func && out_func.out_size > 1 && options[:out]
-          out_args = out_func.args.last(2).map { |a| a[:name] }
-          out_args.zip(options.delete(:out)).each do |k, v|
-            options[k.to_sym] = v
-          end
-          candidates = [out_func]
-        end
-
-        # exclude functions where options don't match
-        options.each do |k, v|
-          candidates.select! do |func|
-            func.args.any? { |a| a[:name] == k.to_s }
-          end
-          # TODO show all bad keywords at once like Ruby?
-          return {error: "unknown keyword: #{k}"} if candidates.empty?
-        end
-
-        final_values = {}
-
-        # check args
-        candidates.select! do |func|
-          good = true
-
-          values = args.zip(func.args).map { |a, fa| [fa[:name], a] }.to_h
-          values.merge!(options.map { |k, v| [k.to_s, v] }.to_h)
-          func.args.each do |fa|
-            values[fa[:name]] = fa[:default] if values[fa[:name]].nil?
-          end
-
-          arg_types = func.args.map { |a| [a[:name], a[:type]] }.to_h
-
-          values.each_key do |k|
-            v = values[k]
-            t = arg_types[k].split("(").first
-
-            good =
-              case t
-              when "Tensor"
-                v.is_a?(Tensor)
-              when "Tensor?"
-                v.nil? || v.is_a?(Tensor)
-              when "Tensor[]", "Tensor?[]"
-                v.is_a?(Array) && v.all? { |v2| v2.is_a?(Tensor) }
-              when "int"
-                if k == "reduction"
-                  v.is_a?(String)
-                else
-                  v.is_a?(Integer)
-                end
-              when "int?"
-                v.is_a?(Integer) || v.nil?
-              when "float"
-                v.is_a?(Numeric)
-              when /int\[.*\]/
-                if v.is_a?(Integer)
-                  size = t[4..-2]
-                  raise Error, "Unknown size: #{size}. Please report a bug with #{@name}." unless size =~ /\A\d+\z/
-                  v = [v] * size.to_i
-                  values[k] = v
-                end
-                v.is_a?(Array) && v.all? { |v2| v2.is_a?(Integer) }
-              when "Scalar"
-                v.is_a?(Numeric)
-              when "ScalarType?"
-                v.nil?
-              when "bool"
-                v == true || v == false
-              when "str"
-                v.is_a?(String)
-              else
-                raise Error, "Unknown argument type: #{arg_types[k]}. Please report a bug with #{@name}."
-              end
-
-            if !good
-              if candidates.size == 1
-                k = "input" if k == "self"
-                return {error: "#{@name}(): argument '#{k}' must be #{t}"}
-              end
-              break
-            end
-          end
-
-          if good
-            final_values = values
-          end
-
-          good
-        end
-
-        if candidates.size != 1
-          raise Error, "This should never happen. Please report a bug with #{@name}."
-        end
-
-        func = candidates.first
-        args = func.args.map { |a| final_values[a[:name]] }
-        args << TensorOptions.new.dtype(6) if func.tensor_options
-        {
-          name: func.cpp_name,
-          args: args
-        }
-      end
-    end
-  end
-end