nn 1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ae8f441634517a886dbdcee8b7186c5d02710c84dc52b381bb29d0d219f958f3
+  data.tar.gz: 3af1f9f95a8727aec20100b1d82ef598dda3857915641a3b73ba16cf372841de
+SHA512:
+  metadata.gz: 2774e79cddbc52530d9f00cd34bb981f7beaa7f6d1c402b6205a41dbe7949fb40dedd2e6c97e9f1a38abc64b5e3bf1bffc40843c943bd0f88dcba2e9bd52f202
+  data.tar.gz: c45b37a70bfddb2a31f1682d4268e943098e228b16102d61b74d2d26dd526b2fd491c4ec4d7a4758cfe838a7511061d4e87b263652acb46a5e29e14d298676bf

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 unagiootoro
+
+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,17 @@
+# ruby-nn
+
+ruby-nnは、rubyで書かれたニューラルネットワークライブラリです。
+python向けの本格的なディープラーニングライブラリと比べると、性能や機能面で、大きく見劣りしますが、
+MNISTで98%以上の精度を出せるぐらいの性能はあります。
+
+## インストール
+
+    $ gem install nn
+
+## 使用法
+
+付属のdocument.txtを参照してください。
+
+## ライセンス
+
+この宝石は、[MITライセンス](https://opensource.org/licenses/MIT)の条件でオープンソースとして入手できます。

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nn"
+
+# 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/document.txt

@@ -0,0 +1,212 @@
+ruby-nnは、rubyで書かれたニューラルネットワークライブラリです。
+python向けの本格的なディープラーニングライブラリと比べると、性能や機能面で、大きく見劣りしますが、
+MNISTで98%以上の精度を出せるぐらいの性能はあります。
+
+なお、ruby-nnはNumo/NArrayを使用しています。
+そのため、ruby-nnの使用には、Numo/NArrayのインストールが必要です。
+
+
+[リファレンス]
+
+class NN
+ニューラルネットワークを扱うクラスです。
+
+<クラスメソッド>
+load(file_name) : NN
+JSON形式で保存された学習結果を読み込みます。
+  String file_name  読み込むJSONファイル名
+  戻り値  NNのインスタンス
+
+<プロパティ>
+Array<SFloat> weights  ネットワークの重みをSFloat形式で取得します。
+Array<SFloat> biases  ネットワークのバイアスをSFloat形式で取得します。
+Array<Float> gammas  バッチノーマライゼーションを使用している場合、gammaを取得します。
+Array<Float> betas  バッチノーマライゼーションを使用している場合、betaを取得します。
+Float learning_rate  学習率
+Integer batch_size  ミニバッチの数
+Array<Symbol> activation  活性化関数。配列の要素1が中間層の活性化関数で要素2が隠れ層の活性化関数です。
+                          中間層には、:sigmoidまたは:relu、出力層には、:identityまたは:softmaxが使用できます。
+Float momentum  モーメンタム係数
+Float weight_decay  L2正則化項の強さ
+Float dropout_ratio  ドロップアウトさせるノードの比率
+
+<インスタンスメソッド>
+initialize(num_nodes,
+           learning_rate: 0.01,
+           batch_size: 1,
+           activation: [:relu, :identity],
+           momentum: 0,
+           weight_decay: 0,
+           use_dropout: false,
+           dropout_ratio: 0.5,
+           use_batch_norm: false)
+オブジェクトを初期化します。
+  Array<Integer> num_nodes  各層のノード数
+  Float learning_rate  学習率
+  Integer batch_size  ミニバッチの数
+  Array<Symbol> activation  活性化関数。配列の要素1が中間層の活性化関数で要素2が隠れ層の活性化関数です。
+                            中間層には、:sigmoidまたは:relu、出力層には、:identityまたは:softmaxが使用できます。
+  Float momentum  モーメンタム係数
+  Float weight_decay  L2正則化項の強さ
+  bool use_dropout  ドロップアウトを使用するか否か
+  Float dropout_ratio  ドロップアウトさせるノードの比率
+  bool use_batch_norm  バッチノーマライゼーションを使用するか否か
+
+train(x_train, y_train, x_test, y_test, epoch,
+      save_dir: nil,
+      save_interval: 1,
+      test: nil,
+      border: nil,
+      tolerance: 0.5,
+      &block) : void
+学習を行います。
+  Array<Array<Numeric>> | SFloat x_train  トレーニング用入力データ。
+  Array<Array<Numeric>> | SFloat y_train　トレーニング用正解データ。
+  Integer epoch  学習回数。入力データすべてを見たタイミングを1エポックとします。
+  String save_dir  学習中にセーブを行う場合、セーブするディレクトリを指定します。nilの場合、セーブを行いません。
+  Integer save_interval  学習中にセーブするタイミングをエポック単位で指定します。
+  Array<Array<Array<Numeric>> | SFloat> test  テストで使用するデータ。[x_test, y_test]の形式で指定してください。
+                                              nilを指定すると、エポックごとにテストを行いません。
+  Float border  学習の早期終了判定に使用するテストデータの正答率。
+                nilの場合、学習の早期終了を行いません。
+  Proc &block(SFloat x, SFloat y) : Array<SFloat>  入力層のミニバッチを取得します。ブロックの戻り値は、ミニバッチを[x, y]の
+                                                   形で指定してください。入力層をミニバッチ単位で正規化したい場合に使用します。
+
+test(x_test, y_test, tolerance = 0.5, &block) : Float
+テストデータを用いて、テストを行います。
+  Array<Array<Numeric>> | SFloat x_train  テスト用入力データ。
+  Array<Array<Numeric>> | SFloat y_train　テスト用正解データ。
+  Float tolerance  許容する誤差。出力層の活性化関数が:identityの場合に使用します。
+                   例えば出力が0.7で正解が1.0の場合、toleranceが0.4なら合格となり、0.2なら不合格となります。
+  Proc &block(SFloat x, SFloat y) : Array<SFloat>  入力層のミニバッチを取得します。ブロックの戻り値は、ミニバッチを[x, y]の
+                                                   形で指定してください。入力層をミニバッチ単位で正規化したい場合に使用します。
+  戻り値  テストデータの正答率。
+
+accurate(x_test, y_test, tolera)
+テストデータを用いて、テストデータの正答率を取得します。
+  Array<Array<Numeric>> | SFloat x_train  テスト用入力データ。
+  Array<Array<Numeric>> | SFloat y_train　テスト用正解データ。
+  Float tolerance  許容する誤差。出力層の活性化関数が:identityの場合に使用します。
+                   例えば出力が0.7で正解が1.0の場合、toleranceが0.4なら合格となり、0.2なら不合格となります。
+  Proc &block(SFloat x, SFloat y) : Array<SFloat>  入力層のミニバッチを取得します。ブロックの戻り値は、ミニバッチを[x, y]の
+                                                   形で指定してください。入力層をミニバッチ単位で正規化したい場合に使用します。
+  戻り値  テストデータの正答率。
+
+learn(x_train, y_train, &block) : Float
+入力データを元に、1回だけ学習を行います。途中で学習を切り上げるなど、柔軟な学習を行いたい場合に使用します。
+  Array<Array<Numeric>> | SFloat x_train  入力データ
+  Array<Array<Numeric>> | SFloat y_train  正解データ
+  Proc &block(SFloat x, SFloat y) : Array<SFloat>  入力層のミニバッチを取得します。ブロックの戻り値は、ミニバッチを[x, y]の
+                                                   形で指定してください。入力層をミニバッチ単位で正規化したい場合に使用します。
+  戻り値  誤差関数の値。誤差関数は、出力層の活性化関数が:identityの場合、二乗和誤差が、
+         :softmaxの場合、クロスエントロピー誤差が使用されます。なお、L2正則化を使用する場合、
+         誤差関数の値には正則化項の値が含まれます。
+
+run(x) : Array<Array<Numeric>>
+入力データから出力値を二次元配列で得ます。
+  Array<Array<Float>> | SFloat x  入力データ
+  戻り値  出力ノードの値
+
+save(file_name) : void
+学習結果をJSON形式で保存します。
+  String file_name  書き込むJSONファイル名
+
+
+[サンプル1 XOR]
+
+#ライブラリの読み込み
+require "nn"
+
+x = [
+  [0, 0],
+  [1, 0],
+  [0, 1],
+  [1, 1],
+]
+
+y = [[0], [1], [1], [0]]
+
+#ニューラルネットワークの初期化
+nn = NN.new([2, 4, 1], #ノード数
+  learning_rate: 0.1, #学習率
+  batch_size: 4, #ミニバッチの数
+  activation: [:sigmoid, :identity] #活性化関数
+)
+
+#学習を行う
+nn.train(x, y, 20000)
+
+#学習結果の確認
+p nn.run(x)
+
+
+[MNISTデータを読み込む]
+MNISTをRubyでも簡単に試せるよう、MNISTを扱うためのモジュールを用意しました。
+次のリンク(http://yann.lecun.com/exdb/mnist/)から、
+train-images-idx3-ubyte.gz
+train-labels-idx1-ubyte.gz
+t10k-images-idx3-ubyte.gz
+t10k-labels-idx1-ubyte.gz
+の4つのファイルをダウンロードし、実行するRubyファイルと同じ階層のmnistディレクトリに格納したうえで、使用してください。
+
+MNIST.load_trainで学習用データを読み込み、MNIST.load_testでテスト用データを読み込みます。
+また、MNIST.categorycalを使用すると、正解データを10クラスにカテゴライズされた上で、配列形式で返します。
+(RubyでのMNISTの読み込みは、以下のリンクを参考にさせていただきました。)
+http://d.hatena.ne.jp/n_shuyo/20090913/mnist
+
+
+[サンプル2 MNIST]
+
+#ライブラリの読み込み
+require "nn"
+require "nn/mnist"
+
+#MNISTのトレーニング用データを読み込む
+x_train, y_train = MNIST.load_train
+
+#y_trainを10クラスに配列でカテゴライズする
+y_train = MNIST.categorical(y_train)
+
+#MNISTのテスト用データを読み込む
+x_test, y_test = MNIST.load_test
+
+#y_testを10クラスにカテゴライズする
+y_test = MNIST.categorical(y_test)
+
+puts "load mnist"
+
+#ニューラルネットワークの初期化
+nn = NN.new([784, 100, 100, 10], #ノード数
+  learning_rate: 0.1, #学習率
+  batch_size: 100, #ミニバッチの数
+  activation: [:relu, :softmax], #活性化関数
+  momentum: 0.9, #モーメンタム係数
+  use_batch_norm: true, #バッチノーマライゼーションを使用する
+)
+
+#学習を行う
+nn.train(x_train, y_train, 10, test: [x_test, y_test]) do |x_batch, y_batch|
+  x_batch /= 255 #ミニバッチを0~1の範囲で正規化
+  [x_batch, y_batch]
+end
+
+#学習結果のテストを行う
+nn.test(x_test, y_test) do |x_batch, y_batch|
+  x_batch /= 255 #ミニバッチを0~1の範囲で正規化
+  [x_batch, y_batch]
+end
+
+
+[お断り]
+作者は、ニューラルネットワークを勉強し始めたばかりの初心者です。
+そのため、バグや実装のミスもあるかと思いますが、温かい目で見守っていただけると、幸いでございます。
+
+
+[更新履歴]
+2018/3/8  バージョン1.0公開
+2018/3/11 バージョン1.1公開
+2018/3/13 バージョン1.2公開
+2018/3/14 バージョン1.3公開
+2018/3/18 バージョン1.4公開
+2018/3/22 バージョン1.5公開
+2018/3/27 RubyGemに公開

data/lib/nn.rb

@@ -0,0 +1,430 @@
+require "numo/narray"
+require "json"
+
+class NN
+  VERSION = "1.5"
+
+  include Numo
+
+  attr_accessor :weights
+  attr_accessor :biases
+  attr_accessor :gammas
+  attr_accessor :betas
+  attr_accessor :learning_rate
+  attr_accessor :batch_size
+  attr_accessor :activation
+  attr_accessor :momentum
+  attr_accessor :weight_decay
+  attr_accessor :dropout_ratio
+  attr_reader :training
+
+  def initialize(num_nodes,
+                 learning_rate: 0.01,
+                 batch_size: 1,
+                 activation: %i(relu identity),
+                 momentum: 0,
+                 weight_decay: 0,
+                 use_dropout: false,
+                 dropout_ratio: 0.5,
+                 use_batch_norm: false)
+    SFloat.srand(rand(2 ** 64))
+    @num_nodes = num_nodes
+    @learning_rate = learning_rate
+    @batch_size = batch_size
+    @activation = activation
+    @momentum = momentum
+    @weight_decay = weight_decay
+    @use_dropout = use_dropout
+    @dropout_ratio = dropout_ratio
+    @use_batch_norm = use_batch_norm
+    init_weight_and_bias
+    init_gamma_and_beta if @use_batch_norm
+    @training = true
+    init_layers
+  end
+
+  def self.load(file_name)
+    json = JSON.parse(File.read(file_name))
+    nn = self.new(json["num_nodes"],
+      learning_rate: json["learning_rate"],
+      batch_size: json["batch_size"],
+      activation: json["activation"].map(&:to_sym),
+      momentum: json["momentum"],
+      weight_decay: json["weight_decay"],
+      use_dropout: json["use_dropout"],
+      dropout_ratio: json["dropout_ratio"],
+      use_batch_norm: json["use_batch_norm"],
+    )
+    nn.weights = json["weights"].map{|weight| SFloat.cast(weight)}
+    nn.biases = json["biases"].map{|bias| SFloat.cast(bias)}
+    if json["use_batch_norm"]
+      nn.gammas = json["gammas"].map{|gamma| SFloat.cast(gamma)}
+      nn.betas = json["betas"].map{|beta| SFloat.cast(beta)}
+    end
+    nn
+  end
+
+  def train(x_train, y_train, epoch,
+            save_dir: nil, save_interval: 1, test: nil, border: nil, tolerance: 0.5, &block)
+    num_train_data = x_train.is_a?(SFloat) ? x_train.shape[0] : x_train.length
+    (epoch * num_train_data / @batch_size).times do |count|
+      loss = learn(x_train, y_train, &block)
+      if loss.nan?
+        puts "loss is nan"
+        break
+      end
+      if (count + 1) % (num_train_data / @batch_size) == 0
+        now_epoch = (count + 1) / (num_train_data / @batch_size)
+        if save_dir && now_epoch % save_interval == 0
+          save("#{save_dir}/epoch#{now_epoch}.json")
+        end
+        msg = "epoch #{now_epoch}/#{epoch} loss: #{loss}"
+        if test
+          acc = accurate(*test, tolerance, &block)
+          puts "#{msg} accurate: #{acc}"
+          break if border && acc >= border
+        else
+          puts msg
+        end
+      end
+    end
+  end
+
+  def test(x_test, y_test, tolerance = 0.5, &block)
+    acc = accurate(x_test, y_test, tolerance, &block)
+    puts "accurate: #{acc}"
+    acc
+  end
+
+  def accurate(x_test, y_test, tolerance = 0.5, &block)
+    correct = 0
+    num_test_data = x_test.is_a?(SFloat) ? x_test.shape[0] : x_test.length
+    (num_test_data / @batch_size).times do |i|
+      x = SFloat.zeros(@batch_size, @num_nodes.first)
+      y = SFloat.zeros(@batch_size, @num_nodes.last)
+      @batch_size.times do |j|
+        k = i * @batch_size + j
+        if x_test.is_a?(SFloat)
+          x[j, true] = x_test[k, true]
+          y[j, true] = y_test[k, true]
+        else
+          x[j, true] = SFloat.cast(x_test[k])
+          y[j, true] = SFloat.cast(y_test[k])
+        end
+      end
+      x, y = block.call(x, y) if block
+      out = forward(x, false)
+      @batch_size.times do |j|
+        vout = out[j, true]
+        vy = y[j, true]
+        case @activation[1]
+        when :identity
+          correct += 1 unless (NMath.sqrt((vout - vy) ** 2) < tolerance).to_a.include?(0)
+        when :softmax
+          correct += 1 if vout.max_index == vy.max_index
+        end
+      end
+    end
+    correct.to_f / num_test_data
+  end
+
+  def learn(x_train, y_train, &block)
+    x = SFloat.zeros(@batch_size, @num_nodes.first)
+    y = SFloat.zeros(@batch_size, @num_nodes.last)
+    @batch_size.times do |i|
+      if x_train.is_a?(SFloat)
+        r = rand(x_train.shape[0])
+        x[i, true] = x_train[r, true]
+        y[i, true] = y_train[r, true]
+      else
+        r = rand(x_train.length)
+        x[i, true] = SFloat.cast(x_train[r])
+        y[i, true] = SFloat.cast(y_train[r])
+      end
+    end
+    x, y = block.call(x, y) if block
+    forward(x)
+    backward(y)
+    update_weight_and_bias
+    update_gamma_and_beta if @use_batch_norm
+    @layers[-1].loss(y)
+  end
+
+  def run(x)
+    x = SFloat.cast(x) if x.is_a?(Array)
+    out = forward(x, false)
+    out.to_a
+  end
+
+  def save(file_name)
+    json = {
+      "version" => VERSION,
+      "num_nodes" => @num_nodes,
+      "learning_rate" => @learning_rate,
+      "batch_size" => @batch_size,
+      "activation" => @activation,
+      "momentum" => @momentum,
+      "weight_decay" => @weight_decay,
+      "use_dropout" => @use_dropout,
+      "dropout_ratio" => @dropout_ratio,
+      "use_batch_norm" => @use_batch_norm,
+      "weights" => @weights.map(&:to_a),
+      "biases" => @biases.map(&:to_a),
+    }
+    if @use_batch_norm
+      json_batch_norm = {
+        "gammas" => @gammas,
+        "betas" => @betas
+      }
+      json.merge!(json_batch_norm)
+    end
+    File.write(file_name, JSON.dump(json))
+  end
+
+  private
+
+  def init_weight_and_bias
+    @weights = Array.new(@num_nodes.length - 1)
+    @biases = Array.new(@num_nodes.length - 1)
+    @weight_amounts = Array.new(@num_nodes.length - 1, 0)
+    @bias_amounts = Array.new(@num_nodes.length - 1, 0)
+    @num_nodes[0...-1].each_index do |i|
+      weight = SFloat.new(@num_nodes[i], @num_nodes[i + 1]).rand_norm
+      bias = SFloat.new(@num_nodes[i + 1]).rand_norm
+      if @activation[0] == :relu
+        @weights[i] = weight / Math.sqrt(@num_nodes[i]) * Math.sqrt(2)
+        @biases[i] = bias / Math.sqrt(@num_nodes[i]) * Math.sqrt(2)
+      else
+        @weights[i] = weight / Math.sqrt(@num_nodes[i])
+        @biases[i] = bias / Math.sqrt(@num_nodes[i])
+      end
+    end
+  end
+
+  def init_gamma_and_beta
+    @gammas = Array.new(@num_nodes.length - 2, 1)
+    @betas = Array.new(@num_nodes.length - 2, 0)
+    @gamma_amounts = Array.new(@num_nodes.length - 2, 0)
+    @beta_amounts = Array.new(@num_nodes.length - 2, 0)
+  end
+
+
+  def init_layers
+    @layers = []
+    @num_nodes[0...-2].each_index do |i|
+      @layers << Affine.new(self, i)
+      @layers << BatchNorm.new(self, i) if @use_batch_norm
+      @layers << case @activation[0]
+      when :sigmoid
+        Sigmoid.new
+      when :relu
+        ReLU.new
+      end
+      @layers << Dropout.new(self) if @use_dropout
+    end
+    @layers << Affine.new(self, -1)
+    @layers << case @activation[1]
+    when :identity
+      Identity.new(self)
+    when :softmax
+      Softmax.new(self)
+    end
+  end
+
+  def forward(x, training = true)
+    @training = training
+    @layers.each do |layer|
+      x = layer.forward(x)
+    end
+    x
+  end
+
+  def backward(y)
+    dout = @layers[-1].backward(y)
+    @layers[0...-1].reverse.each do |layer|
+      dout = layer.backward(dout)
+    end
+  end
+
+  def update_weight_and_bias
+    @layers.select{|layer| layer.is_a?(Affine)}.each.with_index do |layer, i|
+      weight_amount = layer.d_weight.mean(0) * @learning_rate
+      @weight_amounts[i] = weight_amount + @momentum * @weight_amounts[i]
+      @weights[i] -= @weight_amounts[i]
+      bias_amount = layer.d_bias.mean * @learning_rate
+      @bias_amounts[i] = bias_amount + @momentum * @bias_amounts[i]
+      @biases[i] -= @bias_amounts[i]
+    end
+  end
+
+  def update_gamma_and_beta
+    @layers.select{|layer| layer.is_a?(BatchNorm)}.each.with_index do |layer, i|
+      gamma_amount = layer.d_gamma.mean * @learning_rate
+      @gamma_amounts[i] = gamma_amount + @momentum * @gamma_amounts[i]
+      @gammas[i] -= @gamma_amounts[i]
+      beta_amount = layer.d_beta.mean * @learning_rate
+      @beta_amounts[i] = beta_amount + @momentum * @beta_amounts[i]
+      @betas[i] -= @beta_amounts[i]
+    end
+  end
+end
+
+
+class NN::Affine
+  include Numo
+
+  attr_reader :d_weight
+  attr_reader :d_bias
+
+  def initialize(nn, index)
+    @nn = nn
+    @index = index
+    @d_weight = nil
+    @d_bias = nil
+  end
+
+  def forward(x)
+    @x = x
+    @x.dot(@nn.weights[@index]) + @nn.biases[@index]
+  end
+
+  def backward(dout)
+    x = @x.reshape(*@x.shape, 1)
+    d_ridge = @nn.weight_decay * @nn.weights[@index]
+    @d_weight = x.dot(dout.reshape(dout.shape[0], 1, dout.shape[1])) + d_ridge
+    @d_bias = dout
+    dout.dot(@nn.weights[@index].transpose)
+  end
+end
+
+
+class NN::Sigmoid
+  def forward(x)
+    @out = 1.0 / (1 + Numo::NMath.exp(-x))
+  end
+
+  def backward(dout)
+    dout * (1.0 - @out) * @out
+  end
+end
+
+
+class NN::ReLU
+  def forward(x)
+    @x = x.clone
+    x[x < 0] = 0
+    x
+  end
+
+  def backward(dout)
+    @x[@x > 0] = 1.0
+    @x[@x <= 0] = 0.0
+    dout * @x
+  end
+end
+
+
+class NN::Identity
+  include Numo
+
+  def initialize(nn)
+    @nn = nn
+  end
+
+  def forward(x)
+    @out = x
+  end
+
+  def backward(y)
+    @out - y
+  end
+
+  def loss(y)
+    ridge = 0.5 * @nn.weight_decay * @nn.weights.reduce(0){|sum, weight| sum + (weight ** 2).sum}
+    0.5 * ((@out - y) ** 2).sum / @nn.batch_size + ridge
+  end
+end
+
+
+class NN::Softmax
+  include Numo
+
+  def initialize(nn)
+    @nn = nn
+  end
+
+  def forward(x)
+    @out = NMath.exp(x) / NMath.exp(x).sum(1).reshape(x.shape[0], 1)
+  end
+
+  def backward(y)
+    @out - y
+  end
+
+  def loss(y)
+    ridge = 0.5 * @nn.weight_decay * @nn.weights.reduce(0){|sum, weight| sum + (weight ** 2).sum}
+    -(y * NMath.log(@out + 1e-7)).sum / @nn.batch_size + ridge
+  end
+end
+
+
+class NN::Dropout
+  include Numo
+
+  def initialize(nn)
+    @nn = nn
+    @mask = nil
+  end
+
+  def forward(x)
+    if @nn.training
+      @mask = SFloat.ones(*x.shape).rand < @nn.dropout_ratio
+      x[@mask] = 0
+    else
+      x *= (1 - @nn.dropout_ratio)
+    end
+    x
+  end
+
+  def backward(dout)
+    dout[@mask] = 0 if @nn.training
+    dout
+  end
+end
+
+
+class NN::BatchNorm
+  include Numo
+
+  attr_reader :d_gamma
+  attr_reader :d_beta
+
+  def initialize(nn, index)
+    @nn = nn
+    @index = index
+  end
+
+  def forward(x)
+    @x = x
+    @mean = x.mean(0)
+    @xc = x - @mean
+    @var = (@xc ** 2).mean(0)
+    @std = NMath.sqrt(@var + 1e-7)
+    @xn = @xc / @std
+    out = @nn.gammas[@index] * @xn + @nn.betas[@index]
+    out.reshape(*@x.shape)
+  end
+
+  def backward(dout)
+    @d_beta = dout.sum(0)
+    @d_gamma = (@xn * dout).sum(0)
+    dxn = @nn.gammas[@index] * dout
+    dxc = dxn / @std
+    dstd = -((dxn * @xc) / (@std ** 2)).sum(0)
+    dvar = 0.5 * dstd / @std
+    dxc += (2.0 / @nn.batch_size) * @xc * dvar
+    dmean = dxc.sum(0)
+    dx = dxc - dmean / @nn.batch_size
+    dx.reshape(*@x.shape)
+  end
+end

data/lib/nn/mnist.rb

@@ -0,0 +1,54 @@
+require "zlib"
+
+module MNIST
+  def self.load_train
+    if File.exist?("mnist/train.marshal")
+      marshal = File.binread("mnist/train.marshal")
+      Marshal.load(marshal)
+    else
+      x_train, y_train = load("mnist/train-images-idx3-ubyte.gz", "mnist/train-labels-idx1-ubyte.gz")
+      marshal = Marshal.dump([x_train, y_train])
+      File.binwrite("mnist/train.marshal", marshal)
+      [x_train, y_train]
+    end
+  end
+
+  def self.load_test
+    if File.exist?("mnist/test.marshal")
+      marshal = File.binread("mnist/test.marshal")
+      Marshal.load(marshal)
+    else
+      x_test, y_test = load("mnist/t10k-images-idx3-ubyte.gz", "mnist/t10k-labels-idx1-ubyte.gz")
+      marshal = Marshal.dump([x_test, y_test])
+      File.binwrite("mnist/test.marshal", marshal)
+      [x_test, y_test]
+    end
+  end
+
+  def self.categorical(y_data)
+    y_data = y_data.map do |label|
+      classes = Array.new(10, 0)
+      classes[label] = 1
+      classes
+    end
+  end
+
+  private_class_method
+
+  def self.load(images_file_name, labels_file_name)
+    images = []
+    labels = nil
+    Zlib::GzipReader.open(images_file_name) do |f|
+      magic, n_images = f.read(8).unpack("N2")
+      n_rows, n_cols = f.read(8).unpack("N2")
+      n_images.times do
+        images << f.read(n_rows * n_cols).unpack("C*")
+      end
+    end
+    Zlib::GzipReader.open(labels_file_name) do |f|
+      magic, n_labels = f.read(8).unpack("N2")
+      labels = f.read(n_labels).unpack("C*")
+    end
+    [images, labels]
+  end
+end

data/lib/nn/version.rb

@@ -0,0 +1,2 @@
+require "nn"
+

data/nn.gemspec

@@ -0,0 +1,39 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nn"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nn"
+  spec.version       = NN::VERSION
+  spec.authors       = ["unagiootoro"]
+  spec.email         = ["ootoro838861@outlook.jp"]
+
+  spec.summary       = %q{Ruby用ニューラルネットワークライブラリ}
+  spec.description   = %q{Rubyでニューラルネットワークを作成できます。}
+  spec.homepage      = "https://github.com/unagiootoro/nn.git"
+  spec.license       = "MIT"
+
+  spec.add_dependency "numo-narray"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+=begin
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+=end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: nn
+version: !ruby/object:Gem::Version
+  version: '1.5'
+platform: ruby
+authors:
+- unagiootoro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Rubyでニューラルネットワークを作成できます。
+email:
+- ootoro838861@outlook.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- document.txt
+- lib/nn.rb
+- lib/nn/mnist.rb
+- lib/nn/version.rb
+- nn.gemspec
+homepage: https://github.com/unagiootoro/nn.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Ruby用ニューラルネットワークライブラリ
+test_files: []