rubyzero 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 998d9df9776d84a808d54a8e7472d4a9ddea9ee6d0c6732705d8204153016b4e
+  data.tar.gz: 77abc1c5ed65a055339150c4443a72622afd5cb8266c6feb17b707b73678e225
+SHA512:
+  metadata.gz: 1ecf6f49bb0d4a182f204f89fc89d456f51871a7707e4b15bd2d232580b9c62673b1e95ae6159ad3a08535a6d4440d916b6916e33065300ea3674026d75470d3
+  data.tar.gz: 5f5837d4f2ca18403ecafba1309ec8c2fe00d317da7dee746c2d5822c933a6d7817db739df0be988c66f1044113f50b2e1f09356210a9f8a1baf9be46bc7546d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rubyzero.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "unicode_plot"
+gem "numo-narray"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 UThree
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Rubyzero
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rubyzero`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubyzero'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rubyzero
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake ` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubyzero.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rubyzero"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rubyzero/core/cast.rb

@@ -0,0 +1,25 @@
+module RubyZero::Core
+    # Tensor class
+    class Tensor
+        CAST_PRIORITY = [
+            RubyZero::Core::DataTypes::Boolean,
+            RubyZero::Core::DataTypes::UInt8,
+            RubyZero::Core::DataTypes::Int8,
+            RubyZero::Core::DataTypes::UInt16,
+            RubyZero::Core::DataTypes::Int16,
+            RubyZero::Core::DataTypes::UInt32,
+            RubyZero::Core::DataTypes::Int32,
+            RubyZero::Core::DataTypes::UInt64,
+            RubyZero::Core::DataTypes::Int64,
+            RubyZero::Core::DataTypes::Float32,
+            RubyZero::Core::DataTypes::Float64,
+            RubyZero::Core::DataTypes::Complex64,
+            RubyZero::Core::DataTypes::Complex128,
+        ]
+        def cast_to(dtype)
+            @dtype = dtype
+            @data = dtype.get_type_on_calculator(@device).cast(@data)
+            return self
+        end
+    end
+end

data/lib/rubyzero/core/core.rb

@@ -0,0 +1,15 @@
+module RubyZero
+    module Core
+
+    end
+end
+
+require_relative './tensor.rb'
+require_relative './device.rb'
+require_relative './dtypes.rb'
+require_relative './tensor_operators.rb'
+require_relative './tensor_backward.rb'
+require_relative './tensor_initialize_methods.rb'
+require_relative './functions/functions.rb'
+require_relative './exceptions.rb'
+require_relative './cast.rb'

data/lib/rubyzero/core/device.rb

@@ -0,0 +1,32 @@
+module RubyZero::Core
+    class Device
+        attr_reader :caluculator, :identifier
+        def initialize(identifier)
+            sym = identifier.to_sym
+            if sym == :cpu
+                @caluculator = Numo
+                @identifier = sym
+            else
+                raise RubyZero::Core::Exceptions::DeviceNotSupported, "Device #{identifier} is not supported."
+            end
+        end
+        def xmo
+            if @identifier == :cpu
+                return Numo
+            end
+        end
+    end
+end
+
+module RubyZero
+    @@ident_device = {}
+    def self.device(identifier)
+        if @@ident_device[identifier]
+            return @@ident_device[identifier]
+        else
+            d = Core::Device.new(identifier)
+            @@ident_device[identifier] = d
+            return d
+        end
+    end
+end

data/lib/rubyzero/core/dtypes.rb

@@ -0,0 +1,115 @@
+module RubyZero::Core
+    module DataTypes
+        # convert Rubyzero datatypes from Numo/Cumo classes.
+        def self.from_xmo_dtype(klass)
+            case klass.name 
+            when "Numo::NArray"
+                return Float64
+            when "Numo::Bit"
+                return Boolean
+            when "Numo::Int8"
+                return Int8
+            when "Numo::Int16"
+                return Int16
+            when "Numo::Int32"
+                return Int32
+            when "Numo::Int64"
+                return Int64
+            when "Numo::UInt8"
+                return UInt8
+            when "Numo::UInt16"
+                return UInt16
+            when "Numo::UInt32"
+                return UInt32
+            when "Numo::UInt64"
+                return UInt64
+            when "Numo::SFloat"
+                return Float32
+            when "Numo::DFloat"
+                return Float64
+            when "Numo::SComplex"
+                return Complex64
+            when "Numo::DComplex"
+                return Complex128
+            end
+        end
+
+        class DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator
+            end
+            def self.[](*data)
+                return Tensor.new(data, dtype:self, device: RubyZero.device(:cpu))
+            end
+        end
+        class Boolean < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::Bit
+            end
+        end
+        class Int8 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::Int8
+            end
+        end
+        class Int16 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::Int16
+            end
+        end
+        class Int32 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::Int32
+            end
+        end
+        class Int64 < DataType
+            def self.get_type_on_calculator
+                device.caluculator::Int64
+            end
+        end
+        class UInt8 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::UInt8
+            end
+        end
+        class UInt16 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::UInt16
+            end
+        end
+        class UInt32 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::UInt32
+            end
+        end
+        class UInt64 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::UInt64
+            end
+        end
+        class Float32 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::SFloat
+            end
+        end
+        class Float64 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::DFloat
+            end
+        end
+        class Complex64 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::SComplex
+            end
+        end
+        class Complex128 < DataType
+            def self.get_type_on_calculator(device)
+                device.caluculator::DComplex
+            end
+        end
+    end
+end
+
+module RubyZero
+    include Core::DataTypes
+end

data/lib/rubyzero/core/exceptions.rb

@@ -0,0 +1,7 @@
+module RubyZero::Core
+    module Exceptions
+        class NoInplementError < StandardError ; end
+        class DeviceNotSupported < StandardError ; end
+        class TypeNotSupported < StandardError ; end
+    end
+end

data/lib/rubyzero/core/functions/activations.rb

@@ -0,0 +1,20 @@
+module RubyZero::Core::Functions
+    class ReLU < Function
+        def forward(x)
+            @path_through = RubyZero::Core::Tensor.new(x.data < 0)
+            @path_through.cast_to(RubyZero::FloatTensor)
+            return x * @path_through
+        end
+        def backward(dy)
+            return [ @path_through * dy ]
+        end
+    end
+
+    class Sigmoid < Function
+        def forward(x)
+            nmath = x.device.caluculator::NMath
+            data = 1.0 / (1.0 + nmath.exp(-x.data))
+            return RubyZero::Core::Tensor.new(data)
+        end
+    end
+end

data/lib/rubyzero/core/functions/elementary_functions.rb

@@ -0,0 +1,29 @@
+module RubyZero::Core::Functions
+    class Log < Function
+        def forward(x1)
+            nmath = x1.device.xmo::NMath
+            new_arr = nmath.log(x1.data)
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+
+        def backward(dy)
+            x1 = @inputs[0]
+            return [dy / x1]
+        end
+    end
+
+    class Exp < Function
+        def forward(x1)
+            nmath = x1.device.xmo::NMath
+            new_arr = nmath.exp(x1.data)
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+
+        def backward(dy)
+            x1 = @inputs[0]
+            return [dy * self.new.call(x1)]
+        end
+    end
+end

data/lib/rubyzero/core/functions/function.rb

@@ -0,0 +1,29 @@
+require_relative '../exceptions.rb'
+
+module RubyZero::Core::Functions
+    # Function class
+    class Function
+        attr_reader :inputs, :output
+        def initialize(*args, **kwargs, &block)
+            
+        end
+        def forward(*args, **kwargs, &block)
+            raise Execptions::NotImplementedError, "#{self.class}#forward() not implemented"
+        end
+        def backward(*args, **kwargs, &block)
+            raise Execptions::NotImplementedError, "#{self.class}#backward() not implemented"
+        end
+        def call(*args)
+            @inputs = args
+            @output = forward(*args)
+            if @inputs.any?{|t| t.requires_grad?}
+                @output.grad_fn = self
+                @output.requires_grad = true
+            end
+            return @output
+        end
+        def inspect
+            return "#<#{self.class}>"
+        end
+    end
+end

data/lib/rubyzero/core/functions/functions.rb

@@ -0,0 +1,10 @@
+module RubyZero::Core
+    module Functions
+
+    end
+end
+
+require_relative './function.rb'
+require_relative './operators.rb'
+require_relative './tensor_functions.rb'
+require_relative './activations.rb'

data/lib/rubyzero/core/functions/operators.rb

@@ -0,0 +1,112 @@
+module RubyZero::Core::Functions
+    class Neg < Function
+        def forward(x1)
+            new_arr = -(x1.data)
+            new_t = RubyZero::Core::Tensor.new(new_arr)
+            return new_t
+        end
+        def backward(dy)
+            return [-dy]
+        end
+    end
+
+    class Add < Function
+        def forward(x1, x2)
+            new_arr = x1.data + x2.data
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return dy, dy
+        end
+    end
+
+    class Sub < Function
+        def forward(x1, x2)
+            new_arr = x1.data - x2.data
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return dy, -dy
+        end
+    end
+
+    class Mul < Function
+        def forward(x1, x2)
+            new_arr = x1.data * x2.data
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            x1, x2 = @inputs
+            return dy * x2, dy * x1
+        end
+    end
+
+    class Div < Function
+        def forward(x1, x2)
+            new_arr = x1.data / x2.data
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            x1, x2 = @inputs
+            return dy / x2, -dy * x1 / x2 ** 2
+        end
+    end
+
+    class Pow < Function
+        def forward(x1, x2)
+            new_arr = x1.data ** x2.data
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy) 
+            x1, x2 = @inputs
+            return dy * x2 * x1 ** (x2 - 1), dy * x1 ** x2 * Log.new().call(x1)
+        end
+    end
+
+    class Log < Function
+        def forward(x1)
+            nmath = x1.device.xmo::NMath
+            new_arr = nmath.log(x1.data)
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+
+        def backward(dy)
+            x1 = @inputs[0]
+            return [dy / x1]
+        end
+    end
+
+    class MulScalar < Function
+        def initialize(scalar)
+            @scalar = scalar
+        end
+        def forward(x1)
+            new_arr = x1.data * @scalar
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy * @scalar]
+        end
+    end
+
+    class DivScalar < Function
+        def initialize(scalar)
+            @scalar = scalar
+        end
+        def forward(x1)
+            new_arr = x1.data / @scalar
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy / @scalar]
+        end
+    end
+end

data/lib/rubyzero/core/functions/tensor_functions.rb

@@ -0,0 +1,123 @@
+module RubyZero::Core::Functions
+    class Reshape < Function
+        def initialize(shape)
+            @dist_shape = shape
+        end
+        def forward(x1)
+            new_arr = x1.data.reshape(@dist_shape)
+            @prev_shape = x1.shape
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy.reshape(@prev_shape)]
+        end
+    end
+    class SwapAxes < Function
+        def initialize(axis1, axis2)
+            @axis1 = axis1
+            @axis2 = axis2
+        end
+        def forward(x1)
+            new_arr = x1.data.swapaxes(@axis1, @axis2)
+            @prev_shape = x1.shape
+            new_t = RubyZero::Core::Tensor.new(new_arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy.swapaxes(@axis1, @axis2)]
+        end
+    end
+    class Repeat < Function
+        def initialize(axis, repeats)
+            @axis = axis
+            @repeats = repeats
+        end
+        def forward(x1)
+            arr = x1.data
+            arr = arr.reshape(*([1] + arr.shape))
+            arr = arr.repeat(@repeats, axis:0)
+            arr = arr.swapaxes(0, @axis)
+            new_t = RubyZero::Core::Tensor.new(arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [ dy.sum(axis: @axis) ]
+        end
+    end
+
+    class Sum < Function
+        def initialize(axis)
+            @axis = axis
+        end
+        def forward(x1)
+            @repeats = x1.shape[@axis]
+            arr = x1.data
+            arr = arr.sum(axis: @axis)
+            new_t = RubyZero::Core::Tensor.new(arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy.repeat(@repeats, axis: @axis) / @repeats]
+        end
+    end
+
+    class Mean < Function
+        def initialize(axis)
+            @axis = axis
+        end
+        def forward(x1)
+            @repeats = x1.shape[@axis]
+            arr = x1.data
+            arr = arr.mean(axis: @axis)
+            new_t = RubyZero::Core::Tensor.new(arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            return [dy.repeat(@repeats, axis: @axis)]
+        end
+    end
+
+    class DotProduct < Function
+        def initialize()
+        end
+        def forward(x1, x2)
+            arr = x1.data.dot(x2.data)
+            new_t = RubyZero::Core::Tensor.new(arr, device: x1.device)
+            return new_t
+        end
+        def backward(dy)
+            x1, x2 = @inputs
+            dx, dy = [dy.dot(x2.swapaxes(0,1)), x1.swapaxes(0,1).dot(dy)]
+            return dx, dy
+        end
+    end
+end
+
+# apply Tensor class
+module RubyZero::Core
+    class Tensor
+        def reshape(shape)
+            return RubyZero::Core::Functions::Reshape.new(shape).call(self)
+        end
+        def swapaxes(axis1, axis2)
+            return RubyZero::Core::Functions::SwapAxes.new(axis1, axis2).call(self)
+        end
+        def repeat(repeats, axis:0)
+            return RubyZero::Core::Functions::Repeat.new(axis, repeats).call(self)
+        end
+        def sum(axis: 0)
+            return RubyZero::Core::Functions::Sum.new(axis).call(self)
+        end
+        def mean(axis: 0)
+            return RubyZero::Core::Functions::Mean.new(axis).call(self)
+        end
+        def dot(other)
+            if other.is_a?(RubyZero::Core::Tensor)
+                return RubyZero::Core::Functions::DotProduct.new().call(self, other)
+            else
+                return self*other
+            end
+        end
+    end
+end