convolver 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99ab37662a25bbb5d060946aff94c533e336db14
-  data.tar.gz: 5ef276e831151248a543a6f33adbb3524c82a37f
+  metadata.gz: 914f6026eed57b309e6a10b58b865b92cce1216c
+  data.tar.gz: 4d2eff7796eddaf75629ec5d90fe1e4e68681d39
 SHA512:
-  metadata.gz: c97668640eb1ac262397b20915e2739ec3617d0c13c6e06a70a5e7306f8bcb85553ae7022160dea7e63c2d9a7325e2e45d641f7949de6c694b5a3eff9f73f54b
-  data.tar.gz: a3f26841861e48034835af3ed730c1a0cae33d565287c4197f772bf7a1ee6de59cfe0c91abfb75fd5d9789fe54a83f34769fb0700ff22e96302571f0b5715099
+  metadata.gz: 7fd430b3292eef1f7246bfb681eb0532d5826b91937c1b9db2c9ccec1dc03f9379c25b863d24a1e531c2922ca032ec290e102371f2d8cff8df149babd0297ca6
+  data.tar.gz: fe553601923c635c3f186676d4571c644b5bd6978654176acce4bdeeadeac77dae1eaae796c4b2059c0aacfdec044c7d4e4381cebd0d93436844dd6ff2a26818

data/README.md

@@ -1,21 +1,18 @@
 # Convolver
 
+[![Gem Version](https://badge.fury.io/rb/convolver.png)](http://badge.fury.io/rb/convolver)
 [![Build Status](https://travis-ci.org/neilslater/convolver.png?branch=master)](http://travis-ci.org/neilslater/convolver)
+[![Dependency Status](https://gemnasium.com/neilslater/convolver.png)](https://gemnasium.com/neilslater/convolver)
 
-Calculates discrete convolution between two multi-dimensional arrays.
+Calculates discrete convolution between two multi-dimensional arrays of floats.
 See http://en.wikipedia.org/wiki/Convolution
 
-## Planned features
-
-The *convolver* gem will eventually contain a basic kit for creating, training and running
-convolutional neural networks. As a side effect of this plan, it currently contains code for
-calculating floating-point convolutions for other types of analysis.
-
 ## Installation
 
 ### Dependency: FFTW3
 
-Before you install *convolver*, you should install FFTW3. See http://www.fftw.org/ for details.
+Before you install *convolver*, you should install the FFTW3 library on your system.
+See http://www.fftw.org/ for details.
 
 ### Installing the gem
 
@@ -41,10 +38,10 @@ Basic convolution:
     => NArray.float(2): [ 0.19, 0.27 ]
 
  * Convolver only works on single-precision floats internally. It will cast NArray types to this, if
-possible, prior to calculating.
+possible, prior to calculating. For best speed, use NArray.sfloat arrays.
 
- * The output is smaller than the input, each dimension is reduced by 1 less than the width of the
-kernel in the same dimension.
+ * The output is smaller than the input, it only contains fully-calculated values. The output size
+is the original size, minus the kernel size, plus 1, in each dimension.
 
  * Convolver expects input a and kernel b to have the same rank, and for the kernel to be same size
 or smaller in all dimensions as the input.
@@ -54,6 +51,11 @@ small convolutions are processed directly by multiplying out all combinations an
 and large convolutions are processed using FFTW3 to convert to frequency space where convolution
 is simpler and faster to calculate, then convert back.
 
+## Convolutional Neural Nets
+
+Code for CNNs in Ruby, based on the convolve_basic method from this gem, is planned for a
+new gem.
+
 ## Contributing
 
 1. Fork it

data/ext/convolver/convolver.c

@@ -7,7 +7,6 @@
 
 #include "narray_shared.h"
 #include "convolve_raw.h"
-#include "cnn_components.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -111,63 +110,10 @@ static VALUE narray_convolve( VALUE self, VALUE a, VALUE b ) {
   return val_c;
 }
 
-/* @overload nn_run_layer( inputs, weights, thresholds )
- * Calculates activations of a fully-connected neural network layer. The transfer function after
- * summing weights and applying threshold is a "ReLU", equivalent to
- *  y = x < 0.0 ? 0.0 : x
- * this is less sophisticated than many other neural net functions (such as sigma), but is fast to
- * calculate and to train.
- * @param [NArray] inputs must be rank 1 array of floats
- * @param [NArray] weights must be rank 2 array of floats, with first dimension size of inputs, and second dimension size equal to number of outputs
- * @param [NArray] thresholds must be rank 1 array of floats, size equal to number of outputs desired
- * @return [NArray] neuron activations
- */
-static VALUE narray_nn_run_single_layer( VALUE self, VALUE inputs, VALUE weights, VALUE thresholds ) {
-  struct NARRAY *na_inputs, *na_weights, *na_thresholds, *na_outputs;
-  volatile VALUE val_inputs, val_weights, val_thresholds, val_outputs;
-  int input_size, output_size;
-  int output_shape[1];
-
-  val_inputs = na_cast_object(inputs, NA_SFLOAT);
-  GetNArray( val_inputs, na_inputs );
-  if ( na_inputs->rank != 1 ) {
-    rb_raise( rb_eArgError, "input must be array of rank 1" );
-  }
-  input_size = na_inputs->total;
-
-  val_weights = na_cast_object(weights, NA_SFLOAT);
-  GetNArray( val_weights, na_weights );
-  if ( na_weights->rank != 2 ) {
-    rb_raise( rb_eArgError, "weights must be array of rank 2" );
-  }
-  if ( na_weights->shape[0] != input_size ) {
-    rb_raise( rb_eArgError, "weights shape mismatch, expected %d across, got %d", input_size, na_weights->shape[0] );
-  }
-  output_size = na_weights->shape[1];
-
-  val_thresholds = na_cast_object(thresholds, NA_SFLOAT);
-  GetNArray( val_thresholds, na_thresholds );
-  if ( na_thresholds->rank != 1 ) {
-    rb_raise( rb_eArgError, "thresholds must be narray of rank 1" );
-  }
-  if ( na_thresholds->shape[0] != output_size ) {
-    rb_raise( rb_eArgError, "thresholds expected size %d, but got %d", output_size, na_thresholds->shape[0] );
-  }
-
-  output_shape[0] = output_size;
-  val_outputs = na_make_object( NA_SFLOAT, 1, output_shape, CLASS_OF( val_inputs ) );
-  GetNArray( val_outputs, na_outputs );
-
-  nn_run_layer_raw( input_size, output_size, (float*) na_inputs->ptr, (float*) na_weights->ptr,
-      (float*) na_thresholds->ptr, (float*) na_outputs->ptr );
-
-  return val_outputs;
-}
-
-
 void Init_convolver() {
   Convolver = rb_define_module( "Convolver" );
   rb_define_singleton_method( Convolver, "convolve_basic", narray_convolve, 2 );
-  rb_define_singleton_method( Convolver, "nn_run_layer", narray_nn_run_single_layer, 3 );
+
+  // private method
   rb_define_singleton_method( Convolver, "fit_kernel_backwards", narray_fit_backwards, 2 );
 }

data/ext/convolver/narray_shared.c

@@ -21,6 +21,25 @@ void na_quick_pos_to_idxs( int rank, int *shape, int pos, int *idxs ) {
   return;
 }
 
+// This is copied from na_array.c, with safety checks and temp vars removed
+inline int na_inline_idxs_to_pos( int rank, int *shape, int *idxs ) {
+  int i, pos = 0;
+  for ( i = rank - 1; i >= 0; i-- ) {
+    pos = pos * shape[i] + idxs[i];
+  }
+  return pos;
+}
+
+// This is inverse of above
+inline void na_inline_pos_to_idxs( int rank, int *shape, int pos, int *idxs ) {
+  int i;
+  for ( i = 0; i < rank; i++ ) {
+    idxs[ i ] = pos % shape[i];
+    pos /= shape[i];
+  }
+  return;
+}
+
 // used to place kernel data into array for FFTW3 processing
 void fit_backwards_raw( int rank, int *dst_shape, float *dst, int *src_shape, float *src, int *shift_shape ) {
   int i, j, size, x;
@@ -30,13 +49,13 @@ void fit_backwards_raw( int rank, int *dst_shape, float *dst, int *src_shape, fl
   for ( j = 0; j < rank; j++ ) { size *= src_shape[j]; }
 
   for ( i = 0; i < size; i++ ) {
-    na_quick_pos_to_idxs( rank, src_shape, i, k_idx );
+    na_inline_pos_to_idxs( rank, src_shape, i, k_idx );
     for ( j = 0; j < rank; j++ ) {
       x =  src_shape[j] - shift_shape[j] - k_idx[j] - 1;
       if ( x < 0 ) x = x + dst_shape[j];
       dst_idx[j] = x;
     }
-    dst[ na_quick_idxs_to_pos( rank, dst_shape, dst_idx ) ] = src[i];
+    dst[ na_inline_idxs_to_pos( rank, dst_shape, dst_idx ) ] = src[i];
   }
   return;
 }

data/lib/convolver/version.rb

@@ -1,3 +1,3 @@
 module Convolver
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: convolver
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Neil Slater
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-27 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -137,8 +137,6 @@ files:
 - README.md
 - Rakefile
 - convolver.gemspec
-- ext/convolver/cnn_components.c
-- ext/convolver/cnn_components.h
 - ext/convolver/convolve_raw.c
 - ext/convolver/convolve_raw.h
 - ext/convolver/convolver.c
@@ -151,7 +149,6 @@ files:
 - spec/convolve_fftw3_spec.rb
 - spec/convolve_spec.rb
 - spec/helpers.rb
-- spec/nn_run_layer_spec.rb
 homepage: http://github.com/neilslater/convolver
 licenses:
 - MIT
@@ -181,5 +178,4 @@ test_files:
 - spec/convolve_fftw3_spec.rb
 - spec/convolve_spec.rb
 - spec/helpers.rb
-- spec/nn_run_layer_spec.rb
 has_rdoc: 

data/ext/convolver/cnn_components.c

@@ -1,52 +0,0 @@
-// ext/convolver/cnn_components.c
-
-#include <xmmintrin.h>
-#include "cnn_components.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Run a single fully-connected layer, calculating output from input
-//
-//    Benchmark: 1024 inputs, 256 outputs. 1000 iterations. 0.56 seconds
-//
-//
-
-void nn_run_layer_raw( int in_size, int out_size,
-    float *in_ptr, float *weights, float *thresholds, float *out_ptr ) {
-  int i, j, in_aligned_size, out_aligned_size, offset;
-  __m128 simd_x, simd_y, simd_t;
-
-  in_aligned_size = 4 * ( in_size/4 );
-  out_aligned_size = 4 * ( out_size/4 );
-
-  // Calculate activation
-  for ( i = 0; i < out_size; i++ ) {
-
-    float t = 0.0;
-    simd_t = _mm_setzero_ps();
-    offset = i * in_size;
-
-    // Use SIMD for all the aligned values in groups of 4
-    for ( j = 0; j < in_aligned_size; j +=4 ) {
-      simd_x = _mm_load_ps( in_ptr + j );
-      // Weights might not align to 16 bytes due to size of layers
-      simd_y = _mm_loadu_ps( weights + (offset + j) );
-      simd_x = _mm_mul_ps( simd_x, simd_y );
-      simd_t = _mm_add_ps( simd_x, simd_t );
-    }
-
-    // Complete any remaining 1,2 or 3 items one at a time
-    for ( j = in_aligned_size; j < in_size; j++ ) {
-      t += in_ptr[ j ] * weights[ offset + j ];
-    }
-
-    out_ptr[i] = simd_t[0] + simd_t[1] + simd_t[2] + simd_t[3] + t;
-  }
-
-  for ( i = 0; i < out_size; i++ ) {
-    out_ptr[i] -= thresholds[i];
-    if ( out_ptr[i] < 0.0 ) { out_ptr[i] = 0.0; }
-  }
-
-  return;
-}

data/ext/convolver/cnn_components.h

@@ -1,14 +0,0 @@
-// ext/convolver/cnn_components.h
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Declarations of narray helper functions
-//
-
-#ifndef CNN_COMPONENTS_H
-#define CNN_COMPONENTS_H
-
-void nn_run_layer_raw( int in_size, int out_size,
-    float *in_ptr, float *weights, float *thresholds, float *out_ptr );
-
-#endif

data/spec/nn_run_layer_spec.rb

@@ -1,25 +0,0 @@
-require 'helpers'
-
-describe Convolver do
-  describe "#nn_run_layer" do
-    it "should calculate basic layer rules" do
-      inputs = NArray[ 1.0 ]
-      weights = NArray[ [ 1.0 ] ]
-      thresholds = NArray[ 0.0 ]
-      outputs = Convolver.nn_run_layer( inputs, weights, thresholds );
-      outputs.should be_narray_like NArray[ 1.0 ]
-
-      inputs = NArray[ 0.5, -0.5 ]
-      weights = NArray[ [ 1.0, 2.0 ], [ 2.0, 1.0 ] ]
-      thresholds = NArray[ 0.0, 0.0 ]
-      outputs = Convolver.nn_run_layer( inputs, weights, thresholds );
-      outputs.should be_narray_like NArray[ 0.0, 0.5 ]
-
-      inputs = NArray[ 0.3, -0.4, 0.8, -0.7 ]
-      weights = NArray[ [ 1.0, 0.25, 0.5, -0.5 ], [ -1.0, -0.25, -0.5, 0.5 ] ]
-      thresholds = NArray[ 0.0, 0.0 ]
-      outputs = Convolver.nn_run_layer( inputs, weights, thresholds );
-      outputs.should be_narray_like NArray[ 0.95, 0.0 ]
-    end
-  end
-end