torch-rb 0.3.7 → 0.4.0

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