caffe 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87a24cb6239268eff1a716f0f770edf6b708d0f3
-  data.tar.gz: 4e589a9b416d7191567d6d07bc7b127d6bded9d4
+  metadata.gz: 0a805f3a1f52051590a5a9f99655b5b0484e18c6
+  data.tar.gz: 460cb54ae69140bca4900bba9fa721f7658bae6e
 SHA512:
-  metadata.gz: 768510fe5634d31bd847593679836ee2b123264693ce3698dd421c30129fa76b7c26194939669e4e55c904c5def2825b5941a9cafec8df0cc2f756a9d146ac15
-  data.tar.gz: b3a6c3de6efe2190be72ac7637c81f300182b7c5b4417fedbfff28eaf42a5f02eab71dc00c17aadf752f104ad60ec1a6110f983d1c78f786a1b1e8f9629da2cb
+  metadata.gz: a1d5e15287db253830036f54bff7a20f6b07e86551ce8cf1d549b66428d130d57b731dfd62b305d843038f9564e0a9330204fff8bda19e29d163dd527160f45c
+  data.tar.gz: 4f104903a669231d236056855572c7060a5afed9c61713b20046578e4d1e4081b7d414253a72abb63fc0b62c280d7e93ee3dfc49f71236903d8c07c9aaaecae4

data/README.md

@@ -45,21 +45,20 @@ Build flags can be passed to `extconf.rb` to specify the `caffe` path and other
 
 If `rake` is used to build the extension, use:
 
-```shell
+```
 $ rake compile -- <build flags>
 ```
 
 If installing from `gem`, use:
 
-```shell
+```
 $ gem install caffe -- <build flags>
 ```
 
 If installing from `bundler`, use:
 
-```shell
+```
 $ bundle config build.caffe <build flags>
-
 $ bundle install
 ```
 
@@ -67,39 +66,108 @@ $ bundle install
 
 If you put all the headers and libs required in default search path (like `/usr/local` & `/usr`), and use the default setting (with GPU mode) then everything should be ok
 
-## Build ##
+## Installation ##
 
-Now the project is not a gem project, so it can be built by `rake`
+```
+$ gem install caffe -- <build flags>
+```
 
-First, use `bundler` to install all the dependencies:
+Using bundler:
 
-```shell
+```
+$ bundle config build.caffe <build flags>
 $ bundle install
 ```
 
-Then, use `rake` to build:
+Require everything with:
+
+```ruby
+require 'caffe'
+```
+
+## Development ##
+
+First clone this repository:
+
+```
+$ git clone git://github.com/gyf1214/ruby-caffe
+```
+
+Then build all prerequisites for gem & test (proto files & test net):
+
+```
+$ rake build:pre
+```
+
+When building proto files, the caffe path (which contains `proto/caffe.proto`) can be specified by `ENV['CAFFE']`, i.e.
+
+```
+$ CAFFE=/path/to/caffe rake build:pre
+```
 
-```shell
+Or by default the path is `.`, so you can just copy / link your `caffe.proto` to `proto/`
+
+Compile C++ extension with:
+
+```
 $ rake compile -- <build flags>
 ```
 
-Test with:
+Build flags & other methods to link caffe are described above
 
-```shell
+Test the code with (which include the rubocop code style check):
+
+```
 $ rake test
 ```
 
-or after compilation:
+Build the gem with:
+
+```
+$ rake build
+```
+
+Which will run all tests and build the gem in `pkg/caffe-<version>.gem`
+
+Install the gem locally with:
+
+```
+$ rake install
+```
+
+### Other rake tasks ###
+
+```
+$ rake rubocop
+```
 
-```shell
+Run the rubocop code style check, you can also run auto correct with `rake rubocop:auto_correct`
+
+```
 $ rake spec
 ```
 
-require the lib with:
+Run rspec only, without checking the dependencies, note that `build:pre` & `compile` must be completed before
+
+```
+$ rake build:proto
+$ rake build:test
+```
+
+The two tasks build proto files and trained model for testing respectively. `ENV['CAFFE']` can be specified when building proto
 
-```ruby
-require './lib/caffe'
 ```
+$ rake clean
+$ rake clobber
+```
+
+The first cleans the temporary files and the second cleans all generated files
+
+```
+$ rake release[remote]
+```
+
+Create a version tag, and push to both git remote & [rubygems.org](https://rubygems.org)
 
 ## Author ##
 

data/ext/caffe/caffe.cc

@@ -2,6 +2,7 @@
 #include "common.hpp"
 #include "blob.hpp"
 #include "net.hpp"
+#include "solver.hpp"
 
 extern "C"
 void Init_caffe() {
@@ -10,4 +11,5 @@ void Init_caffe() {
     Init_common();
     Init_blob();
     Init_net();
+    Init_solver();
 }

data/ext/caffe/net.cc

@@ -36,7 +36,7 @@ static Object getBlobByName(Object self, String name) {
 static Object forward(Object self) {
     Net *net = from_ruby<Net *>(self);
     float loss = .0;
-    net -> Forward(NULL);
+    net -> Forward(&loss);
     return to_ruby(loss);
 }
 
@@ -51,5 +51,7 @@ void Init_net() {
         .define_method("blob", &getBlobByName)
         .define_method("reshape!", &Net::Reshape)
         .define_method("load_trained!", &Net::CopyTrainedLayersFromBinaryProto)
-        .define_method("forward!", &forward);
+        .define_method("forward!", &forward)
+        .define_method("forward_backward!", &Net::ForwardBackward)
+        .define_method("share_trained!", &Net::ShareTrainedLayersWith);
 }

data/ext/caffe/solver.cc

@@ -0,0 +1,61 @@
+#include "solver.hpp"
+#include "net.hpp"
+#include "util.hpp"
+#include <iostream>
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/String.hpp>
+
+using namespace Rice;
+
+struct SolverConstructor {
+    static void construct(Object self, String path) {
+        caffe::SolverParameter param;
+        caffe::ReadSolverParamsFromTextFileOrDie(path.str(), &param);
+        Solver *solver = SolverRegistry::CreateSolver(param);
+        DATA_PTR(self.value()) = solver;
+    }
+};
+
+static Object getNet(Object self) {
+    Solver *solver = from_ruby<Solver *>(self);
+    Net *net = solver -> net().get();
+
+    if (net) {
+        return objectNoGC(net);
+    } else {
+        return Qnil;
+    }
+}
+
+static Object getTestNets(Object self) {
+    Solver *solver = from_ruby<Solver *>(self);
+    const std::vector<boost::shared_ptr<Net> > &nets = solver -> test_nets();
+    return mapArray(nets.begin(), nets.end(),
+                    sharedToObj<Net, boost::shared_ptr<Net> >);
+}
+
+static void restore(Object self, String path) {
+    Solver *solver = from_ruby<Solver *>(self);
+    solver -> Restore(path.c_str());
+}
+
+static void solve(Object self) {
+    Solver *solver = from_ruby<Solver *>(self);
+    solver -> Solve(NULL);
+}
+
+void Init_solver() {
+    Module rb_mCaffe = define_module("Caffe");
+
+    Data_Type<Solver> rb_cSolver = rb_mCaffe
+        .define_class<Solver>("Solver")
+        .define_constructor(SolverConstructor())
+        .define_method("net", getNet)
+        .define_method("test_nets", getTestNets)
+        .define_method("iter", &Solver::iter)
+        .define_method("step!", &Solver::Step)
+        .define_method("snapshot", &Solver::Snapshot)
+        .define_method("restore!", restore)
+        .define_method("solve!", solve);
+}

data/ext/caffe/solver.hpp

@@ -0,0 +1,11 @@
+#ifndef __SOLVER
+#define __SOLVER
+
+#include <caffe/caffe.hpp>
+
+typedef caffe::Solver<float> Solver;
+typedef caffe::SolverRegistry<float> SolverRegistry;
+
+void Init_solver(void);
+
+#endif

data/ext/caffe/util.hpp

@@ -1,6 +1,7 @@
 #ifndef __UTIL
 #define __UTIL
 
+#include <caffe/caffe.hpp>
 #include <rice/Data_Type.hpp>
 #include <rice/Array.hpp>
 #include <vector>
@@ -17,6 +18,11 @@ Rice::Data_Object<T> objectNoGC(T *obj) {
                                 EmptyFreeFunction<T>::free);
 }
 
+template<typename T, typename U>
+Rice::Data_Object<T> sharedToObj(U obj) {
+    return objectNoGC(obj.get());
+}
+
 template<typename Iter, typename Func>
 Rice::Array mapArray(Iter begin, Iter end, Func func) {
     Rice::Array ret;

data/lib/caffe/version.rb

@@ -1,3 +1,3 @@
 module Caffe
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/spec/common_spec.rb

@@ -22,5 +22,8 @@ RSpec.describe Caffe do
     expect(Caffe.solver_count).to eq(2)
     expect(Caffe.solver_rank).to eq(1)
     expect(Caffe.multiprocess).to eq(true)
+    Caffe.solver_count = 1
+    Caffe.solver_rank = 0
+    Caffe.multiprocess = false
   end
 end

data/spec/net/test.prototxt

@@ -12,6 +12,21 @@ layer {
     }
 }
 
+layer {
+    name: "label"
+    type: "Input"
+    top: "label"
+    include {
+        phase: TRAIN
+    }
+    input_param {
+        shape: {
+            dim: 1
+            dim: 1
+        }
+    }
+}
+
 layer {
     name: "ip1"
     type: "InnerProduct"
@@ -68,4 +83,18 @@ layer {
     type: "Softmax"
     bottom: "ip2"
     top: "prob"
+    include {
+        phase: TEST
+    }
+}
+
+layer {
+    name: "loss"
+    type: "SoftmaxWithLoss"
+    bottom: "ip2"
+    bottom: "label"
+    top: "loss"
+    include {
+        phase: TRAIN
+    }
 }

data/spec/net/test_solver.prototxt

@@ -1,14 +1,14 @@
-net: "test_train.prototxt"
+net: "spec/net/test_train.prototxt"
 test_iter: 100
-test_interval: 800
+test_interval: 80
 base_lr: 0.1
 momentum: 0.9
 weight_decay: 0.0005
 lr_policy: "inv"
 gamma: 0.0001
 power: 0.75
-display: 800
-max_iter: 25600
-snapshot: 25600
-snapshot_prefix: "test"
+display: 80
+max_iter: 2560
+snapshot: 2560
+snapshot_prefix: "spec/net/test"
 solver_mode: CPU

data/spec/net/test_train.prototxt

@@ -6,7 +6,7 @@ layer {
     top: "data"
     top: "label"
     data_param {
-        source: "test_data"
+        source: "spec/net/test_data"
         batch_size: 256
         backend: LMDB
     }

data/spec/net_spec.rb

@@ -1,43 +1,68 @@
 RSpec.describe Caffe::Net do
   before :example do
     Caffe.mode = Caffe::CPU
-    path = File.expand_path '../net/test.prototxt', __FILE__
-    @net = Caffe::Net.new path, Caffe::TEST
+    @path = File.expand_path '../net/test.prototxt', __FILE__
   end
 
-  it 'can get the input' do
-    expect(@net.inputs).to be_an(Array)
-    expect(@net.inputs.size).to eq(1)
-    input = @net.inputs[0]
-    expect(input).to be_a(Caffe::Blob)
-    expect(input.shape).to eq([1, 32])
-  end
+  shared_examples :net do
+    before :example do
+      @net = Caffe::Net.new @path, @phase
+    end
 
-  it 'can get blob by name' do
-    blob = @net.blob('ip1')
-    expect(blob).to be_a(Caffe::Blob)
-    expect(blob.shape).to eq([1, 100])
+    it 'can get the input' do
+      expect(@net.inputs).to be_an(Array)
+      expect([1, 2]).to include(@net.inputs.size)
+      input = @net.inputs[0]
+      expect(input).to be_a(Caffe::Blob)
+      expect(input.shape).to eq([1, 32])
+      if @net.inputs.size == 2
+        input = @net.inputs[1]
+        expect(input).to be_a(Caffe::Blob)
+        expect(input.shape).to eq([1, 1])
+      end
+    end
 
-    blob = @net.blob('prob')
-    expect(blob.shape).to eq([1, 2])
-  end
+    it 'can get blob by name' do
+      blob = @net.blob('ip1')
+      expect(blob).to be_a(Caffe::Blob)
+      expect(blob.shape).to eq([1, 100])
 
-  it 'can get output' do
-    expect(@net.outputs).to be_an(Array)
-    expect(@net.outputs.size).to eq(1)
-    output = @net.outputs[0]
-    expect(output).to be_a(Caffe::Blob)
-    expect(output.shape).to eq([1, 2])
-  end
+      blob = @net.blob('ip2')
+      expect(blob.shape).to eq([1, 2])
+    end
+
+    it 'can get output' do
+      expect(@net.outputs).to be_an(Array)
+      expect(@net.outputs.size).to eq(1)
+      output = @net.outputs[0]
+      expect(output).to be_a(Caffe::Blob)
+      expect([[1, 2], []]).to include(output.shape)
+    end
 
-  it 'can reshape according to the input size' do
-    input = @net.inputs[0]
-    input.shape = [64, 32]
-    @net.reshape!
-    expect(@net.outputs[0].shape).to eq([64, 2])
+    it 'can reshape according to the input size' do
+      @net.inputs.each do |input|
+        shape = input.shape
+        shape[0] = 64
+        input.shape = shape
+      end
+      @net.reshape!
+      expect(@net.blob('ip2').shape).to eq([64, 2])
+    end
+
+    def input_data
+      data = Array.new 32 do
+        Random.rand 2
+      end
+      @net.inputs[0].copy_from! data
+
+      num = data.inject(0) do |i, x|
+        2 * i + x
+      end
+      num % 1024 > 1024 / 2 ? 1 : 0
+    end
   end
 
-  context 'trained net' do
+  shared_examples :trained do
     before :example do
       path = File.expand_path '../net/test.caffemodel', __FILE__
       @net.load_trained! path
@@ -47,25 +72,98 @@ RSpec.describe Caffe::Net do
       input = @net.inputs[0]
       expect(input.shape).to eq([1, 32])
     end
+  end
 
-    it 'can forward' do
-      data = Array.new 32 do
-        Random.rand 2
-      end
-      input = @net.inputs[0]
-      input.copy_from! data
+  shared_examples :shared_net do
+    before :example do
+      @src = @net
+      @net = Caffe::Net.new @path, Caffe::TEST
+      @net.share_trained! @src
+    end
 
+    it 'can forward and return the same result' do
+      input_data
+      @src.inputs[0].copy_from! @net.inputs[0].to_a
       expect(@net.forward!).to eq(0.0)
-      output = @net.outputs[0]
-      expect(output[0][0] + output[0][1]).to be_within(1e-6).of(1.0)
+      @src.forward!
 
-      label = output[0][1] > output[0][0] ? 1 : 0
-      num = data.inject(0) do |i, x|
-        2 * i + x
+      expect(@net.blob('ip1').to_a).to eq(@src.blob('ip1').to_a)
+      expect(@net.blob('ip2').to_a).to eq(@src.blob('ip2').to_a)
+    end
+  end
+
+  context 'test net' do
+    before :example do
+      @phase = Caffe::TEST
+    end
+    include_examples :net
+
+    context 'shared with another' do
+      include_examples :shared_net
+    end
+
+    context 'trained' do
+      include_examples :trained
+
+      context 'share with another' do
+        include_examples :shared_net
+      end
+
+      it 'can forward' do
+        expected = input_data
+
+        expect(@net.forward!).to eq(0.0)
+        output = @net.outputs[0]
+        expect(output[0][0] + output[0][1]).to be_within(1e-6).of(1.0)
+
+        label = output[0][1] > output[0][0] ? 1 : 0
+        expect(label).to eq(expected)
+      end
+
+      it 'can forward then backward' do
+        expect(@net.forward_backward!).to eq(0.0)
       end
-      expected = num % 1024 > 1024 / 2 ? 1 : 0
+    end
+  end
+
+  context 'train net' do
+    before :example do
+      @mode = Caffe::TRAIN
+    end
+    include_examples :net
+
+    context 'share with another' do
+      include_examples :shared_net
+    end
+
+    context 'trained' do
+      include_examples :trained
 
-      expect(label).to eq(expected)
+      context 'share with another' do
+        include_examples :shared_net
+      end
+
+      it 'can forward' do
+        expected = input_data
+        @net.inputs[1][0][0] = expected
+
+        loss = @net.forward!
+        expect(loss).not_to eq(0.0)
+        expect(loss).to be_within(1e-2).of(0.0)
+      end
+
+      it 'can forward then backward' do
+        ip2 = @net.blob 'ip2'
+        expect(ip2.diff[0][0]).to eq(0.0)
+        expect(ip2.diff[0][1]).to eq(0.0)
+
+        loss = @net.forward_backward!
+        expect(loss).not_to eq(0.0)
+        expect(loss).to be_within(1e-2).of(0.0)
+
+        expect(ip2.diff[0][0]).not_to eq(0.0)
+        expect(ip2.diff[0][1]).not_to eq(0.0)
+      end
     end
   end
 end

data/spec/solver_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe Caffe::Solver do
+  before :example do
+    path = File.expand_path '../net/test_solver.prototxt', __FILE__
+    @solver = Caffe::Solver.new path
+  end
+
+  it '#net returns the train net' do
+    net = @solver.net
+    expect(net).to be_a(Caffe::Net)
+    expect(net.inputs.size).to eq(0)
+    expect(net.outputs.size).to eq(1)
+  end
+
+  it '#test_nets returns an array of test nets' do
+    nets = @solver.test_nets
+    expect(nets).to be_an(Array)
+    expect(nets.size).to eq(1)
+    net = nets[0]
+    expect(net).to be_a(Caffe::Net)
+    expect(net.outputs.size).to eq(2)
+  end
+
+  it '#iter returns the current iteration' do
+    expect(@solver.iter).to eq(0)
+  end
+
+  it '#step! steps the iteration' do
+    net = @solver.net
+    loss = net.forward!
+    @solver.step! 100
+    expect(@solver.iter).to eq(100)
+    expect(net.forward!).to be < loss
+  end
+
+  def snapshot_path
+    state = File.expand_path "../net/test_iter_#{@solver.iter}.solverstate",
+                             __FILE__
+    model = File.expand_path "../net/test_iter_#{@solver.iter}.caffemodel",
+                             __FILE__
+    [state, model]
+  end
+
+  it '#snapshot & #restore! can save & load the current state' do
+    state, model = snapshot_path
+    begin
+      @solver.snapshot
+      expect(File.exist?(state)).to be true
+      @solver.restore! state
+    ensure
+      File.unlink state
+      File.unlink model
+    end
+  end
+
+  it '#solve! solves the net' do
+    begin
+      @solver.solve!
+      net = @solver.net
+      expect(net.forward!).to be_within(1e-2).of(0.0)
+    ensure
+      state, model = snapshot_path
+      File.unlink state
+      File.unlink model
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: caffe
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tiny Tiny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -101,6 +101,8 @@ files:
 - ext/caffe/mkmf_cxx.rb
 - ext/caffe/net.cc
 - ext/caffe/net.hpp
+- ext/caffe/solver.cc
+- ext/caffe/solver.hpp
 - ext/caffe/util.hpp
 - lib/caffe.rb
 - lib/caffe/blob.rb
@@ -110,11 +112,11 @@ files:
 - spec/blob_spec.rb
 - spec/common_spec.rb
 - spec/net/gen_data.rb
-- spec/net/test.caffemodel
 - spec/net/test.prototxt
 - spec/net/test_solver.prototxt
 - spec/net/test_train.prototxt
 - spec/net_spec.rb
+- spec/solver_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/gyf1214/ruby-caffe
 licenses:
@@ -144,9 +146,9 @@ test_files:
 - spec/blob_spec.rb
 - spec/common_spec.rb
 - spec/net/gen_data.rb
-- spec/net/test.caffemodel
 - spec/net/test.prototxt
 - spec/net/test_solver.prototxt
 - spec/net/test_train.prototxt
 - spec/net_spec.rb
+- spec/solver_spec.rb
 - spec/spec_helper.rb