ruby-dnn 1.1.4 → 1.2.2

data/examples/judge-number/make_weights.rb

@@ -0,0 +1,5 @@
+require "dnn"
+require_relative "convnet8"
+
+model = ConvNet.load("trained_mnist_epoch20.marshal")
+model.save_params("trained_mnist_params.marshal")

data/examples/judge-number/mnist_predict.rb

@@ -0,0 +1,20 @@
+require "dnn"
+require "dnn/image"
+require_relative "convnet8"
+
+def load_model
+  return if $model
+  $model = ConvNet.create([28, 28, 1])
+  $model.predict1(Numo::SFloat.zeros(28, 28, 1))
+  $model.load_params("trained_mnist_params.marshal")
+end
+
+def mnist_predict(img, width, height)
+  load_model
+  img = DNN::Image.from_binary(img, height, width, DNN::Image::RGBA)
+  img = DNN::Image.to_rgb(img)
+  img = DNN::Image.to_gray_scale(img)
+  x = Numo::SFloat.cast(img) / 255
+  out = $model.predict1(x)
+  out.to_a.map { |v| v.round(4) * 100 }
+end

data/examples/judge-number/mnist_train.rb

@@ -0,0 +1,19 @@
+require "dnn"
+require "dnn/datasets/mnist"
+require_relative "convnet8"
+
+include DNN::Callbacks
+
+x_train, y_train = DNN::MNIST.load_train
+x_test, y_test = DNN::MNIST.load_test
+
+x_train = Numo::SFloat.cast(x_train) / 255
+x_test = Numo::SFloat.cast(x_test) / 255
+
+y_train = DNN::Utils.to_categorical(y_train, 10, Numo::SFloat)
+y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
+
+model = ConvNet.create([28, 28, 1])
+model.add_callback(CheckPoint.new("trained/trained_mnist", interval: 5))
+
+model.train(x_train, y_train, 20, batch_size: 128, test: [x_test, y_test])

data/examples/judge-number/public/httpRequest.js

@@ -0,0 +1,44 @@
+class HttpRequest {
+    static get(path, responseCallback) {
+        const req = new HttpRequest(path, "GET", responseCallback);
+        req.send();
+        return req;
+    }
+
+    static post(path, params, responseCallback) {
+        const req = new HttpRequest(path, "POST", responseCallback);
+        req.send(params);
+        return req;
+    }
+
+    constructor(path, method, responseCallback) {
+        this._path = path;
+        this._method = method;
+        this._responseCallback = responseCallback;
+    }
+
+    send(params = null) {
+        const xhr = new XMLHttpRequest();
+        xhr.open(this._method, this._path);
+        let json = null;
+        if (params) json = JSON.stringify(params);
+        xhr.addEventListener("load", (e) => {
+            const res = {
+                response: xhr.response,
+                event: e
+            };
+            this._responseCallback(res);
+        });
+        xhr.send(json);
+    }
+}
+
+class Base64 {
+    static encode(obj) {
+        if (typeof(obj) === "string") {
+            return btoa(obj);
+        } else if (obj instanceof Uint8Array || obj instanceof Uint8ClampedArray) {
+            return btoa(String.fromCharCode(...obj));
+        }
+    }
+}

data/examples/judge-number/public/judgeNumber.js

@@ -0,0 +1,61 @@
+const drawCanvas = document.getElementById("draw");
+const viewCanvas = document.getElementById("view");
+
+const drawContext = drawCanvas.getContext("2d");
+drawContext.fillRect(0, 0, drawCanvas.width, drawCanvas.height);
+const viewContext = viewCanvas.getContext("2d");
+viewContext.fillRect(0, 0, drawCanvas.width, drawCanvas.height);
+
+const judgeButton = document.getElementById("judge");
+const clearButton = document.getElementById("clear");
+
+const resultArea = document.getElementById("result");
+
+const updateResult = (classification) => {
+    let str = "";
+    for(let i = 0; i <= 9; i++){
+        str += `${i}: ${classification[i]}%<br>`;
+    }
+    resultArea.innerHTML = str;
+};
+
+judgeButton.addEventListener("click", () =>{
+    viewContext.drawImage(drawCanvas, 0, 0, viewCanvas.width, viewCanvas.height);
+    const data = viewContext.getImageData(0, 0, viewCanvas.width, viewCanvas.height).data;
+    params = {
+        img: Base64.encode(data),
+        width: viewCanvas.width,
+        height: viewCanvas.height,
+    }
+    HttpRequest.post("/predict", params, (res) => {
+        updateResult(JSON.parse(res.response));
+    });
+});
+
+clearButton.addEventListener("click", () =>{
+    drawContext.fillStyle = "black";
+    drawContext.fillRect(0, 0, drawCanvas.width, drawCanvas.height);
+    viewContext.fillStyle = "black";
+    viewContext.fillRect(0, 0, drawCanvas.width, drawCanvas.height);
+    result.innerHTML = "";
+});
+
+let mouseDown = false;
+
+window.addEventListener("mousedown", e =>{
+    mouseDown = true;
+});
+
+window.addEventListener("mouseup", e =>{
+    mouseDown = false;
+});
+
+drawCanvas.addEventListener("mousemove", e =>{
+    if(mouseDown){
+        let rect = e.target.getBoundingClientRect();
+        let x = e.clientX - 10 - rect.left;
+        let y = e.clientY - 10 - rect.top;
+        drawContext.fillStyle = "white";
+        drawContext.fillRect(x, y, 20, 20);
+    }
+});

data/examples/judge-number/server.rb

@@ -0,0 +1,19 @@
+require "sinatra"
+require "sinatra/reloader"
+require "json"
+require "base64"
+require_relative "mnist_predict"
+
+get "/" do
+  erb :index
+end
+
+post "/predict" do
+  json = request.body.read
+  params = JSON.parse(json, symbolize_names: true)
+  img = Base64.decode64(params[:img])
+  width = params[:width].to_i
+  height = params[:height].to_i
+  result = mnist_predict(img, width, height)
+  JSON.dump(result)
+end

data/examples/judge-number/views/index.erb

@@ -0,0 +1,7 @@
+<canvas id="draw" width=256 height=256></canvas>
+<canvas id="view" width=28 height=28></canvas>
+<button id="judge">Judge</button>
+<button id="clear">Clear</button>
+<p id="result"></p>
+<script src="judgeNumber.js"></script>
+<script src="httpRequest.js"></script>

data/examples/mnist_conv2d_example.rb

@@ -21,13 +21,13 @@ model = Sequential.new
 
 model << InputLayer.new([28, 28, 1])
 
-model << Conv2D.new(16, 5)
+model << Conv2D.new(16, 3)
 model << BatchNormalization.new
 model << ReLU.new
 
 model << MaxPool2D.new(2)
 
-model << Conv2D.new(32, 5)
+model << Conv2D.new(32, 3)
 model << BatchNormalization.new
 model << ReLU.new
 
@@ -42,7 +42,7 @@ model << Dense.new(10)
 
 model.setup(Adam.new, SoftmaxCrossEntropy.new)
 
-model.train(x_train, y_train, 10, batch_size: 100, test: [x_test, y_test])
+model.train(x_train, y_train, 10, batch_size: 128, test: [x_test, y_test])
 
 accuracy, loss = model.evaluate(x_test, y_test)
 puts "accuracy: #{accuracy}"

data/examples/mnist_define_by_run.rb

@@ -1,7 +1,7 @@
 require "dnn"
 require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
-require "numo/linalg/autoloader"
+# require "numo/linalg/autoloader"
 
 include DNN::Models
 include DNN::Layers
@@ -23,18 +23,18 @@ y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
 class MLP < Model
   def initialize
     super
-    @l1 = Dense.new(256)
-    @l2 = Dense.new(256)
-    @l3 = Dense.new(10)
+    @d1 = Dense.new(256)
+    @d2 = Dense.new(256)
+    @d3 = Dense.new(10)
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/mnist_gpu.rb

@@ -0,0 +1,47 @@
+require "cumo/narray"
+require "dnn"
+require "dnn/datasets/mnist"
+
+include DNN::Models
+include DNN::Layers
+include DNN::Optimizers
+include DNN::Losses
+
+x_train, y_train = DNN::MNIST.load_train
+x_test, y_test = DNN::MNIST.load_test
+
+x_train = x_train.reshape(x_train.shape[0], 784)
+x_test = x_test.reshape(x_test.shape[0], 784)
+
+x_train = Numo::SFloat.cast(x_train) / 255
+x_test = Numo::SFloat.cast(x_test) / 255
+
+y_train = DNN::Utils.to_categorical(y_train, 10, Numo::SFloat)
+y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
+
+if DNN.use_cumo?
+  x_train = DNN::Utils.numo2cumo(x_train)
+  y_train = DNN::Utils.numo2cumo(y_train)
+  x_test = DNN::Utils.numo2cumo(x_test)
+  y_test = DNN::Utils.numo2cumo(y_test)
+end
+
+model = Sequential.new
+
+model << InputLayer.new(784)
+
+model << Dense.new(256)
+model << ReLU.new
+
+model << Dense.new(256)
+model << ReLU.new
+
+model << Dense.new(10)
+
+model.setup(Adam.new, SoftmaxCrossEntropy.new)
+
+model.train(x_train, y_train, 10, batch_size: 128, test: [x_test, y_test])
+
+accuracy, loss = model.evaluate(x_test, y_test)
+puts "accuracy: #{accuracy}"
+puts "loss: #{loss}"

data/examples/mnist_lstm_example.rb

@@ -31,7 +31,7 @@ model << Dense.new(10)
 
 model.setup(Adam.new, SoftmaxCrossEntropy.new)
 
-model.train(x_train, y_train, 10, batch_size: 100, test: [x_test, y_test])
+model.train(x_train, y_train, 10, batch_size: 128, test: [x_test, y_test])
 
 accuracy, loss = model.evaluate(x_test, y_test)
 puts "accuracy: #{accuracy}"

data/examples/pix2pix/dcgan.rb

@@ -2,20 +2,19 @@ include DNN::Models
 include DNN::Layers
 
 class Generator < Model
-  def initialize(input_shape)
+  def initialize(input_shape, base_num_filters)
     super()
     @input_shape = input_shape
-    @l1 = Conv2D.new(32, 4, padding: true)
-    @l2 = Conv2D.new(32, 4, strides: 2, padding: true)
-    @l3 = Conv2D.new(64, 4, padding: true)
-    @l4 = Conv2D.new(64, 4, strides: 2, padding: true)
-    @l5 = Conv2D.new(128, 4, padding: true)
-    @l6 = Conv2DTranspose.new(64, 4, strides: 2, padding: true)
-    @l7 = Conv2D.new(64, 4, padding: true)
-    @l8 = Conv2DTranspose.new(32, 4, strides: 2, padding: true)
-    @l9 = Conv2D.new(32, 4, padding: true)
-    @l10 = Conv2D.new(32, 4, padding: true)
-    @l11 = Conv2D.new(3, 4, padding: true)
+    @cv1 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv2 = Conv2D.new(base_num_filters, 4, strides: 2, padding: true)
+    @cv3 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv4 = Conv2D.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @cv5 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv6 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv7 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv8 = Conv2D.new(3, 4, padding: true)
+    @cvt1 = Conv2DTranspose.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @cvt2 = Conv2DTranspose.new(base_num_filters, 4, strides: 2, padding: true)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
     @bn3 = BatchNormalization.new
@@ -24,113 +23,102 @@ class Generator < Model
     @bn6 = BatchNormalization.new
     @bn7 = BatchNormalization.new
     @bn8 = BatchNormalization.new
-    @bn9 = BatchNormalization.new
   end
 
   def forward(x)
     input = InputLayer.new(@input_shape).(x)
-    x = @l1.(input)
+    x = @cv1.(input)
     x = @bn1.(x)
-    h1 = ReLU.(x)
+    h1 = LeakyReLU.(x, 0.2)
 
-    x = @l2.(h1)
+    x = @cv2.(h1)
     x = @bn2.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l3.(x)
+    x = @cv3.(x)
     x = @bn3.(x)
-    h2 = ReLU.(x)
+    h2 = LeakyReLU.(x, 0.2)
 
-    x = @l4.(x)
+    x = @cv4.(h2)
     x = @bn4.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l5.(x)
+    x = @cv5.(x)
     x = @bn5.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l6.(x)
+    x = @cvt1.(x)
     x = @bn6.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
+    x = Concatenate.(x, h2, axis: 3)
 
-    x = @l7.(x)
+    x = @cv6.(x)
     x = @bn7.(x)
-    x = ReLU.(x)
-    x = Concatenate.(x, h2, axis: 3)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l8.(x)
+    x = @cvt2.(x)
     x = @bn8.(x)
-    x = ReLU.(x)
-
-    x = @l9.(x)
-    x = @bn9.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
     x = Concatenate.(x, h1, axis: 3)
 
-    x = @l10.(x)
-    x = ReLU.(x)
+    x = @cv7.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l11.(x)
+    x = @cv8.(x)
     x = Tanh.(x)
     x
   end
 end
 
 class Discriminator < Model
-  def initialize(gen_input_shape, gen_output_shape)
+  def initialize(gen_input_shape, gen_output_shape, base_num_filters)
     super()
     @gen_input_shape = gen_input_shape
     @gen_output_shape = gen_output_shape
-    @l1_1 = Conv2D.new(32, 4, padding: true)
-    @l1_2 = Conv2D.new(32, 4, padding: true)
-    @l2 = Conv2D.new(32, 4, strides: 2, padding: true)
-    @l3 = Conv2D.new(32, 4, padding: true)
-    @l4 = Conv2D.new(64, 4, strides: 2, padding: true)
-    @l5 = Conv2D.new(64, 4, padding: true)
-    @l6 = Dense.new(1024)
-    @l7 = Dense.new(1)
-    @bn1 = BatchNormalization.new
+    @cv1_1 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv1_2 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv2 = Conv2D.new(base_num_filters, 4, strides: 2, padding: true)
+    @cv3 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv4 = Conv2D.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @d1 = Dense.new(1024)
+    @d2 = Dense.new(1)
+    @bn1_1 = BatchNormalization.new
+    @bn1_2 = BatchNormalization.new
     @bn2 = BatchNormalization.new
     @bn3 = BatchNormalization.new
     @bn4 = BatchNormalization.new
-    @bn5 = BatchNormalization.new
-    @bn6 = BatchNormalization.new
   end
 
   def forward(inputs)
     input, images = *inputs
     x = InputLayer.new(@gen_input_shape).(input)
-    x = @l1_1.(x)
-    x = @bn1.(x)
+    x = @cv1_1.(x)
+    x = @bn1_1.(x)
     x1 = LeakyReLU.(x, 0.2)
 
     x = InputLayer.new(@gen_output_shape).(images)
-    x = @l1_2.(x)
-    x = @bn2.(x)
+    x = @cv1_2.(x)
+    x = @bn1_2.(x)
     x2 = LeakyReLU.(x, 0.2)
 
     x = Concatenate.(x1, x2)
-    x = @l2.(x)
-    x = @bn3.(x)
-    x = LeakyReLU.(x, 0.2)
-
-    x = @l3.(x)
-    x = @bn4.(x)
+    x = @cv2.(x)
+    x = @bn2.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l4.(x)
-    x = @bn5.(x)
+    x = @cv3.(x)
+    x = @bn3.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l5.(x)
-    x = @bn6.(x)
+    x = @cv4.(x)
+    x = @bn4.(x)
     x = LeakyReLU.(x, 0.2)
 
     x = Flatten.(x)
-    x = @l6.(x)
+    x = @d1.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l7.(x)
+    x = @d2.(x)
     x
   end
 
@@ -139,7 +127,7 @@ class Discriminator < Model
       layer.trainable = true
     end
   end
-  
+
   def disable_training
     trainable_layers.each do |layer|
       layer.trainable = false