torch-rb 0.3.7 → 0.5.1

data/lib/torch/native/function.rb

@@ -1,200 +0,0 @@
-module Torch
-  module Native
-    class Function
-      attr_reader :function, :tensor_options
-
-      def initialize(function)
-        @function = function
-
-        # note: don't modify function in-place
-        @tensor_options_str = ", *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None)"
-        @tensor_options = @function["func"].include?(@tensor_options_str)
-        @out = out_size > 0 && base_name[-1] != "_"
-      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.sub(@tensor_options_str, ")").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.to_sym, type: t, default: d, pos: pos, has_default: has_default}
-          end
-          args
-        end
-      end
-
-      def arg_checkers
-        @arg_checkers ||= begin
-          checkers = {}
-          arg_types.each do |k, t|
-            checker =
-              case t
-              when "Tensor"
-                ->(v) { v.is_a?(Tensor) }
-              when "Tensor?"
-                ->(v) { v.nil? || v.is_a?(Tensor) }
-              when "Tensor[]", "Tensor?[]"
-                ->(v) { v.is_a?(Array) && v.all? { |v2| v2.is_a?(Tensor) } }
-              when "int"
-                if k == :reduction
-                  ->(v) { v.is_a?(String) }
-                else
-                  ->(v) { v.is_a?(Integer) }
-                end
-              when "int?"
-                ->(v) { v.is_a?(Integer) || v.nil? }
-              when "float?"
-                ->(v) { v.is_a?(Numeric) || v.nil? }
-              when "bool?"
-                ->(v) { v == true || v == false || v.nil? }
-              when "float"
-                ->(v) { v.is_a?(Numeric) }
-              when /int\[.*\]/
-                ->(v) { v.is_a?(Array) && v.all? { |v2| v2.is_a?(Integer) } }
-              when "Scalar"
-                ->(v) { v.is_a?(Numeric) }
-              when "Scalar?"
-                ->(v) { v.is_a?(Numeric) || v.nil? }
-              when "ScalarType"
-                ->(v) { false } # not supported yet
-              when "ScalarType?"
-                ->(v) { v.nil? }
-              when "bool"
-                ->(v) { v == true || v == false }
-              when "str"
-                ->(v) { v.is_a?(String) }
-              else
-                raise Error, "Unknown argument type: #{t}. Please report a bug with #{@name}."
-              end
-            checkers[k] = checker
-          end
-          checkers
-        end
-      end
-
-      def int_array_lengths
-        @int_array_lengths ||= begin
-          ret = {}
-          arg_types.each do |k, t|
-            if t.match?(/\Aint\[.+\]\z/)
-              size = t[4..-2]
-              raise Error, "Unknown size: #{size}. Please report a bug with #{@name}." unless size =~ /\A\d+\z/
-              ret[k] = size.to_i
-            end
-          end
-          ret
-        end
-      end
-
-      def arg_names
-        @arg_names ||= args.map { |a| a[:name] }
-      end
-
-      def arg_types
-        @arg_types ||= args.map { |a| [a[:name], a[:type].split("(").first] }.to_h
-      end
-
-      def arg_defaults
-        # TODO find out why can't use select here
-        @arg_defaults ||= args.map { |a| [a[:name], a[:default]] }.to_h
-      end
-
-      def out_size
-        @out_size ||= func.split("->").last.count("!")
-      end
-
-      def ret_size
-        @ret_size ||= func.split("->").last.split(", ").size
-      end
-
-      def ret_array?
-        @ret_array ||= func.split("->").last.include?('[]')
-      end
-
-      def ret_void?
-        func.split("->").last.strip == "()"
-      end
-
-      def out?
-        @out
-      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,178 +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 = ["Layout", "Storage", "ConstQuantizerPtr"]
-
-          # remove functions
-          functions.reject! do |f|
-            f.ruby_name.start_with?("_") ||
-            f.ruby_name.include?("_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|
-                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"
-
-%{functions}
-
-void add_%{type}_functions(Module m) {
-  %{add_functions}
-}
-        TEMPLATE
-
-          cpp_defs = []
-          add_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[]", "Tensor?[]"
-                  # TODO make optional
-                  "std::vector<Tensor>"
-                when "int"
-                  "int64_t"
-                when "int?"
-                  "torch::optional<int64_t>"
-                when "float?"
-                  "torch::optional<double>"
-                when "bool?"
-                  "torch::optional<bool>"
-                when "Scalar?"
-                  "torch::optional<torch::Scalar>"
-                when "float"
-                  "double"
-                when /\Aint\[/
-                  "std::vector<int64_t>"
-                when /Tensor\(\S!?\)/
-                  "Tensor &"
-                when "str"
-                  "std::string"
-                when "TensorOptions"
-                  "const torch::TensorOptions &"
-                when "Layout?"
-                  "torch::optional<Layout>"
-                when "Device?"
-                  "torch::optional<Device>"
-                when "Scalar", "bool", "ScalarType", "Layout", "Device", "Storage"
-                  a[:type]
-                else
-                  raise "Unknown type: #{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(", ")})"
-
-            if func.cpp_name == "_fill_diagonal_"
-              body = "to_ruby<torch::Tensor>(#{body})"
-            elsif !func.ret_void?
-              body = "wrap(#{body})"
-            end
-
-            cpp_defs << "// #{func.func}
-static #{func.ret_void? ? "void" : "Object"} #{type}#{func.cpp_name}(#{cpp_args.join(", ")})
-{
-  return #{body};
-}"
-
-            add_defs << "m.#{def_method}(\"#{func.cpp_name}\", #{type}#{func.cpp_name});"
-          end
-
-          hpp_contents = hpp_template % {type: type}
-          cpp_contents = cpp_template % {type: type, functions: cpp_defs.join("\n\n"), add_functions: add_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,117 +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
-        @int_array_first = @functions.all? { |c| c.args.first && c.args.first[:type] == "int[]" }
-      end
-
-      # TODO improve performance
-      # possibly move to C++ (see python_arg_parser.cpp)
-      def parse(args, options)
-        candidates = @functions.dup
-
-        # TODO check candidates individually to see if they match
-        if @int_array_first
-          int_args = []
-          while args.first.is_a?(Integer)
-            int_args << args.shift
-          end
-          if int_args.any?
-            raise ArgumentError, "argument '#{candidates.first.args.first[:name]}' must be array of ints, but found element of type #{args.first.class.name} at pos #{int_args.size + 1}" if args.any?
-            args.unshift(int_args)
-          end
-        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 }
-
-        # handle out with multiple
-        # there should only be one match, so safe to modify all
-        if options[:out]
-          if (out_func = candidates.find { |f| f.out? }) && out_func.out_size > 1
-            out_args = out_func.args.last(2).map { |a| a[:name] }
-            out_args.zip(options.delete(:out)).each do |k, v|
-              options[k] = v
-            end
-            candidates = [out_func]
-          end
-        else
-          # exclude functions missing required options
-          candidates.reject!(&:out?)
-        end
-
-        final_values = nil
-
-        # check args
-        while (func = candidates.shift)
-          good = true
-
-          # set values
-          # TODO use array instead of hash?
-          values = {}
-          args.each_with_index do |a, i|
-            values[func.arg_names[i]] = a
-          end
-          options.each do |k, v|
-            values[k] = v
-          end
-          func.arg_defaults.each do |k, v|
-            values[k] = v unless values.key?(k)
-          end
-          func.int_array_lengths.each do |k, len|
-            values[k] = [values[k]] * len if values[k].is_a?(Integer)
-          end
-
-          arg_checkers = func.arg_checkers
-
-          values.each_key do |k|
-            unless arg_checkers.key?(k)
-              good = false
-              if candidates.empty?
-                # TODO show all bad keywords at once like Ruby?
-                return {error: "unknown keyword: #{k}"}
-              end
-              break
-            end
-
-            unless arg_checkers[k].call(values[k])
-              good = false
-              if candidates.empty?
-                t = func.arg_types[k]
-                k = :input if k == :self
-                return {error: "#{@name}(): argument '#{k}' must be #{t}"}
-              end
-              break
-            end
-          end
-
-          if good
-            final_values = values
-            break
-          end
-        end
-
-        unless final_values
-          raise Error, "This should never happen. Please report a bug with #{@name}."
-        end
-
-        args = func.arg_names.map { |k| final_values[k] }
-        args << TensorOptions.new.dtype(6) if func.tensor_options
-        {
-          name: func.cpp_name,
-          args: args
-        }
-      end
-    end
-  end
-end