caffe 0.1.0

checksums.yaml

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Tiny Tiny
+
+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,110 @@
+# Ruby Caffe #
+
+A ruby wrapper for the deep learning framework
+
+## Linking caffe ##
+
+There is a linking problem since `caffe` doesn't provide an official installation plan, but everything in its build path / distribute path instead of somewhere like `/usr` or `/usr/local`
+
+Now `extconf.rb` only checks for `cblas.h` (or `mkl.h` if you are using Intel MKL), `-lcaffe` and `caffe/caffe.hpp`, other dependent headers of `caffe` (such as `leveldb`) should be installed in default search path (`/usr/include` or `/usr/local/include`), or you can use `pkg-config` to add additional options in `LDFLAGS` & `CFLAGS` directly (see below)
+
+There are three options to specify the path of the libraries & headers:
+
+### `pkg-config` ###
+
+Ruby `mkmf` provide convenient use of `pkg-config`, which is included in `extconf.rb`. It will search for `caffe.pc` in `pkg-config` search paths (typically `/usr/lib/pkgconfig` and `/usr/local/lib/pkgconfig`)
+
+However `caffe` doesn't provide a `.pc` file, but you can write one yourself, here is an example:
+
+```
+prefix=/usr/local/caffe
+libdir=${prefix}/lib
+includedir=${prefix}/include
+blasinclude=/usr/local/openblas/include
+otherflags=-DCPU_ONLY
+
+Name: caffe
+Description: caffe C++ lib
+Version: 1.0.0-rc4
+Libs: -L${libdir} -lcaffe
+CFlags: ${otherflags} -I${includedir} -I${blasinclude}
+```
+
+Note that `pkg-config` directly adds `LDFLAGS` & `CFLAGS`, so you can add flags other than what `extconf.rb` specifies
+
+### Build Flags ###
+
+Build flags can be passed to `extconf.rb` to specify the `caffe` path and other configuration:
+
+- `--with-caffe-dir=<path>`: specify the caffe path, in which `<path>/include` contains the headers and `<path>/lib` contains the library
+- `--with-caffe-include` & `--with-caffe-lib`: specify the caffe header and lib path separately
+- `--with-blas-include=<path>`: specify the path that contains the blas headers
+- `--with-blas-dir=<path>`: the same as `--with-blas-include=<path>/include`
+- `--enable-gpu` & `--disable-gpu`: specify GPU mode of caffe, enabled by default
+- `--enable-mkl` & `--disable-mkl`: specify if Intel MKL is used as blas library, if neither flags are set `extconf.rb` will search for `cblas.h` first and then `mkl.h` if fails
+
+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
+```
+
+### Put everything in search path ###
+
+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 ##
+
+Now the project is not a gem project, so it can be built by `rake`
+
+First, use `bundler` to install all the dependencies:
+
+```shell
+$ bundle install
+```
+
+Then, use `rake` to build:
+
+```shell
+$ rake compile -- <build flags>
+```
+
+Test with:
+
+```shell
+$ rake test
+```
+
+or after compilation:
+
+```shell
+$ rake spec
+```
+
+require the lib with:
+
+```ruby
+require './lib/caffe'
+```
+
+## Author ##
+
+Tiny Tiny
+
+## License ##
+
+MIT

data/ext/caffe/blob.cc

@@ -0,0 +1,145 @@
+#include "blob.hpp"
+#include "util.hpp"
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Module.hpp>
+#include <stdexcept>
+#include <algorithm>
+
+using namespace Rice;
+
+BlobCursor::BlobCursor(Object blob, bool diff) : diff(diff) {
+    ref = from_ruby<Blob *>(blob);
+}
+
+void BlobCursor::checkValid() const {
+    int n = indices.size();
+    const std::vector<int> &shape = ref -> shape();
+    if (n > shape.size()) throw std::logic_error("Invalid BlobCursor!");
+    for (int i = 0; i < n; ++i) {
+        if (shape[i] <= indices[i]) {
+            throw std::out_of_range("Index out of range!");
+        }
+    }
+}
+
+BlobCursor BlobCursor::next(int index) const {
+    BlobCursor ret = *this;
+    ret.indices.push_back(index);
+    ret.checkValid();
+    return ret;
+}
+
+Object BlobCursor::get(int index) const {
+    BlobCursor next = this -> next(index);
+    if (next.indices.size() == ref -> shape().size()) {
+        return to_ruby(*next.begin());
+    } else {
+        return to_ruby(next);
+    }
+}
+
+Object BlobCursor::set(int index, Object data) {
+    BlobCursor next = this -> next(index);
+    if (next.indices.size() == ref -> shape().size()) {
+        *next.mbegin() = from_ruby<float>(data);
+        return data;
+    } else {
+        throw std::logic_error("Not implemented!");
+    }
+}
+
+const float *BlobCursor::begin() {
+    std::vector<int> full = indices;
+    full.resize(ref -> shape().size());
+    const float *base = diff ? ref -> cpu_diff() : ref -> cpu_data();
+
+    return base + ref -> offset(full);
+}
+
+const float *BlobCursor::end() {
+    return begin() + count();
+}
+
+float *BlobCursor::mbegin() {
+    std::vector<int> full = indices;
+    full.resize(ref -> shape().size());
+    float *base = diff ? ref -> mutable_cpu_diff() : ref -> mutable_cpu_data();
+
+    return base + ref -> offset(full);
+}
+
+float *BlobCursor::mend() {
+    return mbegin() + count();
+}
+
+int BlobCursor::count() const {
+    const std::vector<int> &shape = ref -> shape();
+    int n = shape.size();
+    int ans = 1;
+    for (int k = indices.size(); k < n; ++k) {
+        ans *= shape[k];
+    }
+    return ans;
+}
+
+int BlobCursor::copy(Array data) {
+    int n = std::min(int(data.size()), count());
+    float *base = mbegin();
+    for (int i = 0; i < n; ++i) {
+        base[i] = from_ruby<float>(data[i]);
+    }
+    return n;
+}
+
+static Object getBlobData(Object self) {
+    return to_ruby(BlobCursor(self));
+}
+
+static Object getBlobDiff(Object self) {
+    return to_ruby(BlobCursor(self, true));
+}
+
+static Array getBlobShape(Object self) {
+    const std::vector<int> &shape = from_ruby<Blob *>(self) -> shape();
+    return Array(shape.begin(), shape.end());
+}
+
+static Array setBlobShape(Object self, Array shape) {
+    if (shape.size() > 4) {
+        throw std::invalid_argument("Shape dimension exceeds 4!");
+    }
+    Blob *blob = from_ruby<Blob *>(self);
+    blob -> Reshape(arrayToVector<int>(shape));
+    return shape;
+}
+
+struct BlobConstructor {
+    static void construct(Object self, Array shape) {
+        if (shape.size() > 4) {
+            throw std::invalid_argument("Shape dimension exceeds 4!");
+        }
+        DATA_PTR(self.value()) = new Blob(arrayToVector<int>(shape));
+    }
+};
+
+void Init_blob() {
+    Module rb_mCaffe = define_module("Caffe");
+
+    Data_Type<Blob> rb_cBlob = rb_mCaffe
+        .define_class<Blob>("Blob")
+        .define_constructor(BlobConstructor())
+        .define_method("data", getBlobData)
+        .define_method("diff", getBlobDiff)
+        .define_method("shape", getBlobShape)
+        .define_method("shape=", setBlobShape);
+
+    Data_Type<BlobCursor> rb_cCursor = rb_cBlob
+        .define_class<BlobCursor>("Cursor")
+        .define_constructor(Constructor<BlobCursor, Object, bool>())
+        .define_method("[]", &BlobCursor::get)
+        .define_method("[]=", &BlobCursor::set)
+        .define_method("size", &BlobCursor::count)
+        .define_iterator(&BlobCursor::begin, &BlobCursor::end)
+        .define_method("copy_from!", &BlobCursor::copy);
+}

data/ext/caffe/blob.hpp

@@ -0,0 +1,32 @@
+#ifndef __BLOB
+#define __BLOB
+
+#include <rice/Class.hpp>
+#include <rice/Array.hpp>
+#include <caffe/caffe.hpp>
+#include <vector>
+#include <stdexcept>
+
+typedef caffe::Blob<float> Blob;
+
+class BlobCursor {
+    std::vector<int> indices;
+    Blob *ref;
+    bool diff;
+    void checkValid(void) const;
+public:
+    BlobCursor(Rice::Object blob, bool diff = false);
+    BlobCursor next(int index) const;
+    Rice::Object get(int index) const;
+    Rice::Object set(int index, Rice::Object data);
+    const float *begin(void);
+    const float *end(void);
+    float *mbegin(void);
+    float *mend(void);
+    int count(void) const;
+    int copy(Rice::Array data);
+};
+
+void Init_blob(void);
+
+#endif

data/ext/caffe/caffe.cc

@@ -0,0 +1,13 @@
+#include <caffe/caffe.hpp>
+#include "common.hpp"
+#include "blob.hpp"
+#include "net.hpp"
+
+extern "C"
+void Init_caffe() {
+    ::google::InitGoogleLogging("ruby-caffe");
+
+    Init_common();
+    Init_blob();
+    Init_net();
+}

data/ext/caffe/common.cc

@@ -0,0 +1,36 @@
+#include "common.hpp"
+#include <rice/Module.hpp>
+#include <rice/Class.hpp>
+#include <caffe/caffe.hpp>
+
+using namespace Rice;
+
+#define EnumCast(type, classname) template<> \
+type from_ruby<type>(Object self) { \
+    int num = from_ruby<int>(self.call("to_i")); \
+    return type(num); \
+} \
+template<> \
+Object to_ruby<type>(const type &self) { \
+    int num = int(self); \
+    Object cl = (classname); \
+    return cl.call("fetch", num); \
+}
+
+EnumCast(caffe::Phase, define_module("Caffe")
+                      .const_get("Phase"));
+EnumCast(caffe::Caffe::Brew, Class(define_module("Caffe")
+                            .const_get("SolverParameter"))
+                            .const_get("SolverMode"));
+
+void Init_common() {
+    Module rb_mCaffe = define_module("Caffe")
+        .define_module_function("mode", caffe::Caffe::mode)
+        .define_module_function("mode=", caffe::Caffe::set_mode)
+        .define_module_function("solver_count", caffe::Caffe::solver_count)
+        .define_module_function("solver_count=", caffe::Caffe::set_solver_count)
+        .define_module_function("solver_rank", caffe::Caffe::solver_rank)
+        .define_module_function("solver_rank=", caffe::Caffe::set_solver_rank)
+        .define_module_function("multiprocess", caffe::Caffe::multiprocess)
+        .define_module_function("multiprocess=", caffe::Caffe::set_multiprocess);
+}

data/ext/caffe/common.hpp

@@ -0,0 +1,17 @@
+#ifndef __COMMON
+#define __COMMON
+
+#include <caffe/caffe.hpp>
+#include <rice/Data_Type.hpp>
+
+#define DefineEnumCast(type) template<> \
+type from_ruby<type>(Rice::Object); \
+template<> \
+Rice::Object to_ruby<type>(const type &)
+
+DefineEnumCast(caffe::Phase);
+DefineEnumCast(caffe::Caffe::Brew);
+
+void Init_common(void);
+
+#endif

data/ext/caffe/extconf.rb

@@ -0,0 +1,39 @@
+require File.expand_path '../mkmf_cxx', __FILE__
+
+@libdir_basename = 'lib'
+
+dir_config 'caffe'
+dir_config 'blas'
+
+checking_for 'caffe.pc' do
+  pkg_config 'caffe'
+end
+
+$libs = ''
+
+$defs.push '-DCPU_ONLY' unless enable_config 'gpu', true
+
+mkl = enable_config 'mkl', nil
+
+if mkl == true || !have_header('cblas.h')
+  $defs.push '-DUSE_MKL'
+  if mkl == false || !have_header('mkl.h')
+    puts <<MSG
+blas header not found.
+use build flag "--with-blas-dir=/path/to/blas" to specify the blas path.
+or use "--with-blas-include" to specify the include path.
+MSG
+    raise
+  end
+end
+
+unless library?('caffe') && header_cxx?('caffe/caffe.hpp')
+  puts <<MSG
+caffe not found.
+use build flag "--with-caffe-dir=/path/to/caffe" to specify the caffe path.
+or use "--with-caffe-include" & "--with-caffe-lib" to specify include path & lib path separately.
+MSG
+  raise
+end
+
+create_makefile 'caffe/caffe'

data/ext/caffe/mkmf_cxx.rb

@@ -0,0 +1,158 @@
+require 'mkmf-rice'
+
+$CXXFLAGS = ''
+
+TRY_LINK.sub!(/^#{Regexp.quote($CXX)}/, '$(CXX)')
+$LDSHARED_CXX.sub!(/^#{Regexp.quote($CXX)}/, '$(CXX)')
+$CXX = '$(CXX)'
+
+if CONFIG['target_os'] == 'mswin32' && $RICE_USING_MINGW32
+  init_rice_mkmf_cross_compile_mingw2_for_vc6
+end
+
+def configuration(srcdir)
+  configuration = configuration_orig(srcdir)
+  configuration.each do |config|
+    # Make sure we link the extension using the C++ compiler
+    config.gsub!(/^LDSHARED\s*=.*$/, "LDSHARED = #{$LDSHARED_CXX}")
+
+    # Make sure set the C++ flags correctly
+    config.gsub!(/^CXXFLAGS\s*=.*$/, "CXXFLAGS = $(CFLAGS) #{$CXXFLAGS}")
+  end
+  configuration
+end
+
+RbConfig::CONFIG['CXXPP'] = RbConfig::CONFIG['CXX'] + ' -E'
+CONFTEST_CC = "#{CONFTEST}.cc".freeze
+
+def create_tmpsrc_cxx(src)
+  src = "#{COMMON_HEADERS}\n#{src}"
+  src = yield(src) if block_given?
+  src.gsub!(/[ \t]+$/, '')
+  src.gsub!(/\A\n+|^\n+$/, '')
+  src.sub!(/[^\n]\z/, "\\&\n")
+  count = 0
+  begin
+    open(CONFTEST_CC, 'wb') do |cfile|
+      cfile.print src
+    end
+  rescue Errno::EACCES
+    if (count += 1) < 5
+      sleep 0.2
+      retry
+    end
+  end
+  src
+end
+
+def try_do_cxx(src, command, *opts, &b)
+  unless have_devel?
+    raise <<MSG
+The compiler failed to generate an executable file.
+You have to install development tools first.
+MSG
+  end
+  begin
+    src = create_tmpsrc_cxx(src, &b)
+    xsystem(command, *opts)
+  ensure
+    log_src(src)
+    MakeMakefile.rm_rf "#{CONFTEST}.dSYM"
+  end
+end
+
+def link_command(ldflags, opt = '', libpath = $DEFLIBPATH | $LIBPATH)
+  librubyarg = $extmk ? $LIBRUBYARG_STATIC : '$(LIBRUBYARG)'
+  conf = RbConfig::CONFIG.merge('hdrdir' => $hdrdir.quote,
+                                'src' => CONFTEST_CC,
+                                'arch_hdrdir' => $arch_hdrdir.quote,
+                                'top_srcdir' => $top_srcdir.quote,
+                                'INCFLAGS' => $INCFLAGS,
+                                'CPPFLAGS' => $CPPFLAGS,
+                                'CXXFLAGS' => $CXXFLAGS,
+                                'CFLAGS' => $CFLAGS,
+                                'ARCH_FLAG' => $ARCH_FLAG,
+                                'LDFLAGS' => "#{$LDFLAGS} #{ldflags}",
+                                'LOCAL_LIBS' => "#{$LOCAL_LIBS} #{$libs}",
+                                'LIBS' => "#{librubyarg} #{opt} #{$LIBS}")
+  conf['LIBPATH'] = libpathflag(libpath.map do |s|
+    RbConfig.expand(s.dup, conf)
+  end)
+  RbConfig.expand(TRY_LINK.dup, conf)
+end
+
+def try_link0(src, opt = '', *opts, &b)
+  cmd = link_command('', opt)
+  if $universal
+    require 'tmpdir'
+    Dir.mktmpdir('mkmf_', oldtmpdir = ENV['TMPDIR']) do |tmpdir|
+      begin
+        ENV['TMPDIR'] = tmpdir
+        try_do_cxx(src, cmd, *opts, &b)
+      ensure
+        ENV['TMPDIR'] = oldtmpdir
+      end
+    end
+  else
+    try_do_cxx(src, cmd, *opts, &b)
+  end && File.executable?(CONFTEST + $EXEEXT)
+end
+
+def cxxpp_command(outfile, opt = '')
+  conf = RbConfig::CONFIG.merge('hdrdir' => $hdrdir.quote,
+                                'srcdir' => $srcdir.quote,
+                                'arch_hdrdir' => $arch_hdrdir.quote,
+                                'top_srcdir' => $top_srcdir.quote)
+  if $universal && (arch_flag = conf['ARCH_FLAG']) && !arch_flag.empty?
+    conf['ARCH_FLAG'] = arch_flag.gsub(/(?:\G|\s)-arch\s+\S+/, '')
+  end
+  flags = [$INCFLAGS, $CPPFLAGS, $CFLAGS, opt].join ' '
+  RbConfig.expand("$(CXXPP) #{flags} #{CONFTEST_CC} #{outfile}", conf)
+end
+
+def try_cxxpp(src, opt = '', *opts, &b)
+  try_do_cxx(src, cxxpp_command(CPPOUTFILE, opt), *opts, &b) &&
+    File.file?('conftest.i')
+ensure
+  MakeMakefile.rm_f 'conftest*'
+end
+
+def trans_opt(opt)
+  [[:to_str], [:join, ' '], [:to_s]].each do |meth, *args|
+    return opt.send(meth, *args) if opt.respond_to?(meth)
+  end
+end
+
+def header_cxx?(header, preheaders = nil, opt = '', &b)
+  opt = "#{trans_opt opt} #{trans_opt $defs}"
+  checking_for header do
+    if try_cxxpp(cpp_include(preheaders) + cpp_include(header), opt, &b)
+      $defs.push(format('-DHAVE_%s', header.tr_cpp))
+      true
+    else
+      false
+    end
+  end
+end
+
+def try_library(libs, opt = '', &b)
+  opt = "#{trans_opt opt} #{libs}"
+  try_link(MAIN_DOES_NOTHING, opt, &b)
+end
+
+def library?(lib, opt = '', &b)
+  lib = with_config(lib + 'lib', lib)
+  checking_for format(LIBARG, lib) do
+    if COMMON_LIBS.include?(lib)
+      true
+    else
+      libs = append_library($libs, lib)
+      if try_library(libs, opt, &b)
+        $libs = libs
+        true
+      else
+        false
+      end
+    end
+  end
+end