Matcaffe2

include/caffe/common.hpp

@@ -125,6 +125,8 @@ class Caffe {
   // Sets the device. Since we have cublas and curand stuff, set device also
   // requires us to reset those values.
   static void SetDevice(const int device_id);
+  // Gets current device_id
+  static int GetDevice();
   // Prints the current GPU status.
   static void DeviceQuery();
 

matlab/caffe/CaffeNet.m

@@ -0,0 +1,252 @@
+classdef CaffeNet < handle
+    properties (SetAccess = private)
+        model_def_file = '../../examples/imagenet/imagenet_deploy.prototxt';
+        model_file = '../../examples/imagenet/caffe_reference_imagenet_model';
+        layers_info
+        blobs_info
+    end
+    properties
+        mode
+        phase
+        device_id
+        input_blobs
+        output_blobs
+    end
+    properties (Dependent)
+        weights
+    end
+    properties (Access = private)
+        init_key
+        weights_changed = true;
+        weights_store
+    end
+    methods (Access=private)
+        function self = CaffeNet(model_def_file, model_file)
+            if nargin == 0
+                init(self, self.model_def_file, self.model_file);
+            end
+            if nargin > 0
+                init_net(self, model_def_file);
+            end
+            if nargin > 1
+                load_net(self, model_file);
+            end
+            assert(is_initialized(self))
+            self.mode = caffe_safe('get_mode');
+            self.phase = caffe_safe('get_phase');
+            self.device_id = caffe_safe('get_device');
+        end
+    end
+    methods (Static)
+        function obj = instance(model_def_file, model_file)
+            persistent self
+            if isempty(self)
+                switch nargin
+                    case 2
+                        self = CaffeNet(model_def_file, model_file);
+                    case 1
+                        self = CaffeNet(model_def_file);
+                    case 0
+                        self = CaffeNet();
+                end
+            else
+                if nargin > 0 && ~isempty(model_def_file)
+                    init_net(self,model_def_file);
+                end
+                if nargin > 1 && ~isempty(model_file)
+                    load_net(self,model_file);
+                end
+            end
+            obj = self;
+        end
+    end
+    methods
+        function weights = get.weights(self)
+            assert(is_initialized(self))
+            if (self.weights_changed)
+                self.weights_store = caffe_safe('get_weights');
+                self.weights_changed = false;
+            end
+            weights = self.weights_store;
+        end
+        function set.weights(self,weights)
+            assert(is_initialized(self))
+            caffe_safe('set_weights', weights);
+            self.weights_store = weights;
+            self.weights_changed = false;
+        end
+        function set.mode(self,mode)
+            % mode = {'CPU' 'GPU'}
+            switch mode
+                case 'CPU'
+                    caffe_safe('set_mode_cpu');
+                    self.mode = mode;
+                case 'GPU'
+                    caffe_safe('set_mode_gpu');
+                    self.mode = mode;
+                otherwise
+                    fprintf('Mode unknown choose between CPU and GPU\n');
+                    error('Mode unknown');
+            end
+        end
+        function set.phase(self, phase)
+            % phase = {'TRAIN' 'TEST'}
+            switch phase
+                case 'TRAIN'
+                    caffe_safe('set_phase_train');
+                    self.phase = phase;
+                case {'test','TEST'}
+                    caffe_safe('set_phase_test');
+                    self.phase = phase;
+                otherwise
+                    fprintf('Phase unknown choose between TRAIN and TEST')
+                    error('Phase unknown');
+            end
+        end
+        function set.device_id(self, device_id)
+            caffe_safe('set_device', device_id);
+            self.device_id = device_id;
+        end
+        function set.input_blobs(self, input_blobs)
+            assert(is_initialized(self))
+            caffe_safe('set_input_blobs', input_blobs);
+            self.input_blobs = input_blobs;
+        end
+        function set.output_blobs(self, output_blobs)
+            assert(is_initialized(self))
+            caffe_safe('set_output_blobs', output_blobs);
+            self.output_blobs = output_blobs;
+        end
+    end
+    methods
+        function res = forward(self,input)
+            assert(is_initialized(self))
+            if nargin < 2
+                res = caffe_safe('forward');
+            else
+                res = caffe_safe('forward',input);
+            end
+        end
+        function res = backward(self,diff)
+            assert(is_initialized(self))
+            if nargin < 2
+                res = caffe_safe('backward');
+            else
+                res = caffe_safe('backward',diff);
+            end
+        end
+        function res = forward_prefilled(self)
+            assert(is_initialized(self))
+            res = caffe_safe('forward_prefilled');
+        end
+        function res = backward_prefilled(self)
+            assert(is_initialized(self))
+            res = caffe_safe('backward_prefilled');
+        end
+        function res = init(self, model_def_file, model_file)
+            self.init_key = caffe_safe('init',model_def_file, model_file);
+            assert(is_initialized(self))
+            self.model_def_file = model_def_file;
+            self.model_file = model_file;
+            self.layers_info = caffe_safe('get_layers_info');
+            self.blobs_info = caffe_safe('get_blobs_info');
+            self.weights_changed = true;
+            res = self.init_key;
+        end
+        function res = init_net(self, model_def_file)
+            self.init_key = caffe_safe('init_net',model_def_file);
+            assert(is_initialized(self))
+            self.model_def_file = model_def_file;
+            self.model_file = [];
+            self.layers_info = caffe_safe('get_layers_info');
+            self.blobs_info = caffe_safe('get_blobs_info');
+            self.weights_changed = true;
+            res = self.init_key;
+        end
+        function res = load_net(self, model_file)
+            assert(is_initialized(self))
+            self.init_key = caffe_safe('load_net',model_file);
+            self.model_file = model_file;
+            self.weights_changed = true;
+            res = self.init_key;
+        end
+        function res = save_net(self, model_file)
+            assert(is_initialized(self))
+            res = caffe_safe('save_net', model_file);
+        end
+        function res = is_initialized(~)
+            res = caffe_safe('is_initialized')>0;
+        end
+        function set_mode_cpu(self)
+            self.mode = 'CPU';
+        end
+        function set_mode_gpu(self)
+            self.mode = 'GPU';
+        end
+        function set_phase_train(self)
+            self.phase = 'TRAIN';
+        end
+        function set_phase_test(self)
+            self.phase = 'TEST';
+        end
+        function set_device(self, device_id)
+            self.device_id = device_id;
+        end
+        function res = get_weights(self)
+            assert(is_initialized(self))
+            res = self.weights;
+        end
+        function set_weights(self, weights)
+            self.weights = weights;
+        end
+        function res = get_layer_weights(self, layer_name)
+            assert(is_initialized(self))
+            res = caffe_safe('get_layer_weights', layer_name);
+        end
+        function res = set_layer_weights(self, layer_name, weights)
+            assert(is_initialized(self))
+            res = caffe_safe('set_layer_weights', layer_name, weights);
+            self.weights = caffe_safe('get_weights');
+        end
+        function res = get_layers_info(self)
+            assert(is_initialized(self))
+            res = self.layers_info;
+        end
+        function res = get_blobs_info(self)
+            assert(is_initialized(self))
+            res = self.blobs_info;
+        end
+        function res = get_blob_data(self, blob_name)
+            assert(is_initialized(self))
+            res = caffe_safe('get_blob_data', blob_name);
+        end
+        function res = get_blob_diff(self, blob_name)
+            assert(is_initialized(self))
+            res = caffe_safe('get_blob_diff', blob_name);
+        end
+        function res = get_all_data(self)
+            assert(is_initialized(self))
+            res = caffe_safe('get_all_data');
+        end
+        function res = get_all_diff(self)
+            assert(is_initialized(self))
+            res = caffe_safe('get_all_diff');
+        end
+        function res = get_init_key(self)
+            self.init_key = caffe_safe('get_init_key');
+            res = self.init_key;
+        end
+        function reset(self)
+            caffe_safe('reset');
+            self.init_key = caffe_safe('get_init_key');
+            self.layers_info = [];
+            self.blobs_info = [];
+            self.weights_store = [];
+        end
+        function delete(self)
+            self.weights_store = [];
+            caffe_safe('reset');
+            clear caffe;
+        end
+    end
+end

matlab/caffe/caffe_safe.m

@@ -0,0 +1,15 @@
+function varargout = caffe_safe(varargin)
+  try
+     switch nargout
+	case 0
+	 caffe(varargin{:});
+	 varargout={};
+	case 1
+	 varargout{1} = caffe(varargin{:});
+	case 2
+	 [varargout{1} varargout{2}] = caffe(varargin{:});
+  end
+  catch
+    error('Exception in caffe');
+  end
+end

matlab/caffe/displayData.m

@@ -0,0 +1,61 @@
+function [h, display_array] = displayData(X, example_width, display_cols)
+%DISPLAYDATA Display 2D data in a nice grid
+%   [h, display_array] = DISPLAYDATA(X, example_width) displays 2D data
+%   stored in X in a nice grid. It returns the figure handle h and the 
+%   displayed array if requested.
+
+% Set example_width automatically if not passed in
+if ~exist('example_width', 'var') || isempty(example_width) 
+	example_width = round(sqrt(size(X, 2)));
+end
+
+% Gray Image
+colormap(gray);
+
+% Compute rows, cols
+[m n] = size(X);
+example_height = (n / example_width);
+
+% Compute number of items to display
+if ~exist('display_cols', 'var')
+    display_cols = floor(sqrt(m));
+end
+display_rows = ceil(m / display_cols);
+
+% Between images padding
+pad = 1;
+
+% Setup blank display
+display_array = - ones(pad + display_rows * (example_height + pad), ...
+                       pad + display_cols * (example_width + pad));
+
+% Copy each example into a patch on the display array
+curr_ex = 1;
+for j = 1:display_rows
+	for i = 1:display_cols
+		if curr_ex > m, 
+			break; 
+		end
+		% Copy the patch
+
+		% Get the max value of the patch
+		max_val = max(abs(X(curr_ex, :)));
+		display_array(pad + (j - 1) * (example_height + pad) + (1:example_height), ...
+		              pad + (i - 1) * (example_width + pad) + (1:example_width)) = ...
+						reshape(X(curr_ex, :), example_height, example_width) / max_val;
+		curr_ex = curr_ex + 1;
+	end
+	if curr_ex > m, 
+		break; 
+	end
+end
+
+% Display Image
+h = imagesc(display_array, [-1 1]);
+
+% Do not show axis
+axis image off
+
+drawnow;
+
+end

matlab/caffe/displayFilters.m

@@ -0,0 +1,31 @@
+function displayFilters(X, display_cols)
+%displayFilters Display [height * width * num_channels * num_filters] filters 
+%  in a nice grid using display_cols, at most it displays 32 filters
+%   [h, display_array] = displayFilters(X, display_cols)
+
+% Gray Image
+colormap(gray);
+
+% Compute rows, cols
+[example_height example_width num_channels num_filters] = size(X);
+
+
+% Compute number of items to display
+if ~exist('display_cols', 'var')
+    display_cols = floor(sqrt(num_filters));
+end
+display_rows = ceil(num_filters / display_cols);
+colimage = [];
+for n = 1:min(32,num_filters)
+    if mod(n,8)== 1
+        figure(ceil(n/8))
+        colimage = [];
+    end
+    filter = reshape(X(:,:,:,n),[],num_channels)';
+    [~,dsp] = displayData(filter,example_width,num_channels/4);
+    colimage = cat(1,colimage,dsp,ones(1,size(dsp,2)));
+    if mod(n,8)== 0
+        imagesc(colimage, [-1 1]), axis off; drawnow;
+    end
+end
+