naming. I might regret it someday.
authorYangqing Jia <jiayq84@gmail.com>
Sun, 22 Sep 2013 17:18:13 +0000 (10:18 -0700)
committerYangqing Jia <jiayq84@gmail.com>
Sun, 22 Sep 2013 17:18:13 +0000 (10:18 -0700)
43 files changed:
src/Makefile
src/caffe.cloc [moved from src/caffeine.cloc with 100% similarity]
src/caffe/blob.cpp [moved from src/caffeine/blob.cpp with 95% similarity]
src/caffe/blob.hpp [moved from src/caffeine/blob.hpp with 87% similarity]
src/caffe/common.cpp [moved from src/caffeine/common.cpp with 68% similarity]
src/caffe/common.hpp [moved from src/caffeine/common.hpp with 75% similarity]
src/caffe/filler.hpp [moved from src/caffeine/filler.hpp with 85% similarity]
src/caffe/layer.hpp [moved from src/caffeine/layer.hpp with 85% similarity]
src/caffe/layers/conv_layer.cpp [moved from src/caffeine/layers/conv_layer.cpp with 90% similarity]
src/caffe/layers/dropout_layer.cu [moved from src/caffeine/layers/dropout_layer.cu with 83% similarity]
src/caffe/layers/im2col_layer.cpp [moved from src/caffeine/layers/im2col_layer.cpp with 93% similarity]
src/caffe/layers/inner_product_layer.cpp [moved from src/caffeine/layers/inner_product_layer.cpp with 79% similarity]
src/caffe/layers/lrn_layer.cpp [moved from src/caffeine/layers/lrn_layer.cpp with 80% similarity]
src/caffe/layers/lrn_layer.cu [moved from src/caffeine/layers/lrn_layer.cu with 93% similarity]
src/caffe/layers/neuron_layer.cpp [moved from src/caffeine/layers/neuron_layer.cpp with 79% similarity]
src/caffe/layers/padding_layer.cu [moved from src/caffeine/layers/padding_layer.cu with 94% similarity]
src/caffe/layers/relu_layer.cu [moved from src/caffeine/layers/relu_layer.cu with 88% similarity]
src/caffe/proto/layer_param.proto [moved from src/caffeine/proto/layer_param.proto with 99% similarity]
src/caffe/proto/layer_param_pb2.pyc [moved from src/caffeine/proto/layer_param_pb2.pyc with 100% similarity]
src/caffe/syncedmem.cpp [moved from src/caffeine/syncedmem.cpp with 93% similarity]
src/caffe/syncedmem.hpp [moved from src/caffeine/syncedmem.hpp with 82% similarity]
src/caffe/test/test_blob.cpp [moved from src/caffeine/test/test_blob.cpp with 93% similarity]
src/caffe/test/test_caffe_main.hpp [moved from src/caffeine/test/test_caffeine_main.hpp with 67% similarity]
src/caffe/test/test_common.cpp [moved from src/caffeine/test/test_common.cpp with 55% similarity]
src/caffe/test/test_convolution_layer.cpp [moved from src/caffeine/test/test_convolution_layer.cpp with 91% similarity]
src/caffe/test/test_filler.cpp [moved from src/caffeine/test/test_filler.cpp with 96% similarity]
src/caffe/test/test_gradient_check_util.hpp [moved from src/caffeine/test/test_gradient_check_util.hpp with 95% similarity]
src/caffe/test/test_im2col_layer.cpp [moved from src/caffeine/test/test_im2col_layer.cpp with 86% similarity]
src/caffe/test/test_innerproduct_layer.cpp [moved from src/caffeine/test/test_innerproduct_layer.cpp with 87% similarity]
src/caffe/test/test_lrn_layer.cpp [moved from src/caffeine/test/test_lrn_layer.cpp with 91% similarity]
src/caffe/test/test_neuron_layer.cpp [moved from src/caffeine/test/test_neuron_layer.cpp with 86% similarity]
src/caffe/test/test_padding_layer.cpp [moved from src/caffeine/test/test_padding_layer.cpp with 85% similarity]
src/caffe/test/test_platform.cpp [new file with mode: 0644]
src/caffe/test/test_protobuf.cpp [moved from src/caffeine/test/test_protobuf.cpp with 86% similarity]
src/caffe/test/test_syncedmem.cpp [moved from src/caffeine/test/test_syncedmem.cpp with 94% similarity]
src/caffe/test/test_util_blas.cpp [moved from src/caffeine/test/test_util_blas.cpp with 75% similarity]
src/caffe/util/im2col.cpp [moved from src/caffeine/util/im2col.cpp with 96% similarity]
src/caffe/util/im2col.cu [moved from src/caffeine/util/im2col.cu with 93% similarity]
src/caffe/util/im2col.hpp [moved from src/caffeine/util/im2col.hpp with 82% similarity]
src/caffe/util/math_functions.cpp [moved from src/caffeine/util/math_functions.cpp with 64% similarity]
src/caffe/util/math_functions.hpp [moved from src/caffeine/util/math_functions.hpp with 57% similarity]
src/caffe/vision_layers.hpp [moved from src/caffeine/vision_layers.hpp with 97% similarity]
src/caffeine/test/test_platform.cpp [deleted file]

index 2b53501a05841c6821c1fb8c69583042e19cc1a7..bc76371d0dd10741f2c1d83a16478842dcbf0125 100644 (file)
@@ -5,14 +5,14 @@
 # using program.NAME, program.C_SRCS, etc. There are no structs in Make, so we use this convention
 # to keep track of attributes that all belong to the same target or program.  
 #
-PROJECT := caffeine
+PROJECT := caffe
 NAME := lib$(PROJECT).so
 TEST_NAME := test_$(PROJECT)
-CXX_SRCS := $(shell find caffeine ! -name "test_*.cpp" -name "*.cpp")
-CU_SRCS := $(shell find caffeine -name "*.cu")
-TEST_SRCS := $(shell find caffeine -name "test_*.cpp")
+CXX_SRCS := $(shell find caffe ! -name "test_*.cpp" -name "*.cpp")
+CU_SRCS := $(shell find caffe -name "*.cu")
+TEST_SRCS := $(shell find caffe -name "test_*.cpp")
 GTEST_SRC := gtest/gtest-all.cpp
-PROTO_SRCS := $(wildcard caffeine/proto/*.proto)
+PROTO_SRCS := $(wildcard caffe/proto/*.proto)
 PROTO_GEN_HEADER := ${PROTO_SRCS:.proto=.pb.h}
 PROTO_GEN_CC := ${PROTO_SRCS:.proto=.pb.cc}
 PROTO_GEN_PY := ${PROTO_SRCS:.proto=_pb2.py}
@@ -50,7 +50,7 @@ NVCC = nvcc ${CXXFLAGS:-fPIC=-Xcompiler -fPIC} $(CPPFLAGS) $(CUDA_ARCH)
 all: $(NAME)
 
 linecount: clean
-       cloc --read-lang-def=caffeine.cloc caffeine/
+       cloc --read-lang-def=caffe.cloc caffe/
 
 test: $(OBJS) $(GTEST_OBJ) $(TEST_BINS)
 
similarity index 100%
rename from src/caffeine.cloc
rename to src/caffe.cloc
similarity index 95%
rename from src/caffeine/blob.cpp
rename to src/caffe/blob.cpp
index 2c5f72451aeec0b50de1aec82c87803278a9d244..b0a576e8786492b89b034d50f10667f434b39c71 100644 (file)
@@ -1,10 +1,10 @@
 #include <cublas_v2.h>
 
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/syncedmem.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void Blob<Dtype>::Reshape(const int num, const int channels, const int height,
@@ -131,5 +131,5 @@ void Blob<Dtype>::ToProto(BlobProto* proto) {
 
 INSTANTIATE_CLASS(Blob);
 
-}  // namespace caffeine
+}  // namespace caffe
 
similarity index 87%
rename from src/caffeine/blob.hpp
rename to src/caffe/blob.hpp
index 1457ee1d9d5d0ec07e2f4ebe37303002492623fd..3320d076b78791c690528776e69113a81e7d34eb 100644 (file)
@@ -1,11 +1,11 @@
-#ifndef CAFFEINE_BLOB_HPP
-#define CAFFEINE_BLOB_HPP
+#ifndef CAFFE_BLOB_HPP
+#define CAFFE_BLOB_HPP
 
-#include "caffeine/common.hpp"
-#include "caffeine/syncedmem.hpp"
-#include "caffeine/proto/layer_param.pb.h"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
+#include "caffe/proto/layer_param.pb.h"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 class Blob {
@@ -60,6 +60,6 @@ class Blob {
   int count_;
 };  // class Blob
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_BLOB_HPP_
+#endif  // CAFFE_BLOB_HPP_
similarity index 68%
rename from src/caffeine/common.cpp
rename to src/caffe/common.cpp
index 2466df4e3d3e27a6f54e3a6f10787fcc4222add4..8477efa05a43c481d25e00d8f48e2e58da49e051 100644 (file)
@@ -1,11 +1,11 @@
-#include "caffeine/common.hpp"
+#include "caffe/common.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-shared_ptr<Caffeine> Caffeine::singleton_;
+shared_ptr<Caffe> Caffe::singleton_;
 
-Caffeine::Caffeine()
-    : mode_(Caffeine::CPU), phase_(Caffeine::TRAIN) {
+Caffe::Caffe()
+    : mode_(Caffe::CPU), phase_(Caffe::TRAIN) {
   CUBLAS_CHECK(cublasCreate(&cublas_handle_));
   CURAND_CHECK(curandCreateGenerator(&curand_generator_,
       CURAND_RNG_PSEUDO_DEFAULT));
@@ -14,7 +14,7 @@ Caffeine::Caffeine()
   VSL_CHECK(vslNewStream(&vsl_stream_, VSL_BRNG_MT19937, 1701));
 }
 
-Caffeine::~Caffeine() {
+Caffe::~Caffe() {
   if (!cublas_handle_) CUBLAS_CHECK(cublasDestroy(cublas_handle_));
   if (!curand_generator_) {
     CURAND_CHECK(curandDestroyGenerator(curand_generator_));
@@ -22,42 +22,42 @@ Caffeine::~Caffeine() {
   if (!vsl_stream_) VSL_CHECK(vslDeleteStream(&vsl_stream_));
 };
 
-Caffeine& Caffeine::Get() {
+Caffe& Caffe::Get() {
   if (!singleton_) {
-    singleton_.reset(new Caffeine());
+    singleton_.reset(new Caffe());
   }
   return *singleton_;
 };
 
-VSLStreamStatePtr Caffeine::vsl_stream() {
+VSLStreamStatePtr Caffe::vsl_stream() {
   return Get().vsl_stream_;
 }
 
-cublasHandle_t Caffeine::cublas_handle() {
+cublasHandle_t Caffe::cublas_handle() {
   return Get().cublas_handle_;
 };
 
-curandGenerator_t Caffeine::curand_generator() {
+curandGenerator_t Caffe::curand_generator() {
   return Get().curand_generator_;
 };
 
-Caffeine::Brew Caffeine::mode() {
+Caffe::Brew Caffe::mode() {
   return Get().mode_;
 }
 
-void Caffeine::set_mode(Caffeine::Brew mode) {
+void Caffe::set_mode(Caffe::Brew mode) {
   Get().mode_ = mode;
 }
 
-Caffeine::Phase Caffeine::phase() {
+Caffe::Phase Caffe::phase() {
   return Get().phase_;
 }
 
-void Caffeine::set_phase(Caffeine::Phase phase) {
+void Caffe::set_phase(Caffe::Phase phase) {
   Get().phase_ = phase;
 }
 
-void Caffeine::set_random_seed(const unsigned int seed) {
+void Caffe::set_random_seed(const unsigned int seed) {
   // Curand seed
   // Yangqing's note: simply setting the generator seed does not seem to
   // work on the tesla K20s, so I wrote the ugly reset thing below. It is not
@@ -72,5 +72,5 @@ void Caffeine::set_random_seed(const unsigned int seed) {
   VSL_CHECK(vslNewStream(&(Get().vsl_stream_), VSL_BRNG_MT19937, seed));
 }
 
-}  // namespace caffeine
+}  // namespace caffe
 
similarity index 75%
rename from src/caffeine/common.hpp
rename to src/caffe/common.hpp
index 9fd50841209518dea49ca1eaae8be934a70a1fa2..be0797f5bc2f84e6aa16f97a9794e3b2f12aa1cb 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef CAFFEINE_COMMON_HPP_
-#define CAFFEINE_COMMON_HPP_
+#ifndef CAFFE_COMMON_HPP_
+#define CAFFE_COMMON_HPP_
 
 #include <boost/shared_ptr.hpp>
 #include <cublas_v2.h>
 
 #define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet"
 
-namespace caffeine {
+namespace caffe {
 
 // We will use the boost shared_ptr instead of the new C++11 one mainly
 // because cuda does not work (at least now) well with C++11 features.
 using boost::shared_ptr;
 
 // For backward compatibility we will just use 512 threads per block
-const int CAFFEINE_CUDA_NUM_THREADS = 512;
+const int CAFFE_CUDA_NUM_THREADS = 512;
 
-inline int CAFFEINE_GET_BLOCKS(const int N) {
-  return (N + CAFFEINE_CUDA_NUM_THREADS - 1) / CAFFEINE_CUDA_NUM_THREADS;
+inline int CAFFE_GET_BLOCKS(const int N) {
+  return (N + CAFFE_CUDA_NUM_THREADS - 1) / CAFFE_CUDA_NUM_THREADS;
 }
 
-// A singleton class to hold common caffeine stuff, such as the handler that
-// caffeine is going to use for cublas.
-class Caffeine {
+// A singleton class to hold common caffe stuff, such as the handler that
+// caffe is going to use for cublas.
+class Caffe {
  public:
-  ~Caffeine();
-  static Caffeine& Get();
+  ~Caffe();
+  static Caffe& Get();
   enum Brew { CPU, GPU };
   enum Phase { TRAIN, TEST};
 
@@ -59,8 +59,8 @@ class Caffeine {
   static void set_phase(Phase phase);
   static void set_random_seed(const unsigned int seed);
  private:
-  Caffeine();
-  static shared_ptr<Caffeine> singleton_;
+  Caffe();
+  static shared_ptr<Caffe> singleton_;
   cublasHandle_t cublas_handle_;
   curandGenerator_t curand_generator_;
   VSLStreamStatePtr vsl_stream_;
@@ -68,6 +68,6 @@ class Caffeine {
   Phase phase_;
 };
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_COMMON_HPP_
+#endif  // CAFFE_COMMON_HPP_
similarity index 85%
rename from src/caffeine/filler.hpp
rename to src/caffe/filler.hpp
index b15b38e4f2700e0feea95d1e30aeda9ab10c154f..1acb86888839bdf317f628301efa5c091c108235 100644 (file)
@@ -2,17 +2,17 @@
 // algorithm. The expectation is that they are only going to be used during
 // initialization time and will not involve any GPUs.
 
-#ifndef CAFFEINE_FILLER_HPP
-#define CAFFEINE_FILLER_HPP
+#ifndef CAFFE_FILLER_HPP
+#define CAFFE_FILLER_HPP
 
 #include <mkl.h>
 
-#include "caffeine/common.hpp"
-#include "caffeine/blob.hpp"
-#include "caffeine/syncedmem.hpp"
-#include "caffeine/proto/layer_param.pb.h"
+#include "caffe/common.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/syncedmem.hpp"
+#include "caffe/proto/layer_param.pb.h"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 class Filler {
@@ -55,12 +55,12 @@ class UniformFiller : public Filler<Dtype> {
     CHECK(count);
     switch(sizeof(Dtype)) {
     case sizeof(float):
-      VSL_CHECK(vsRngUniform(VSL_RNG_METHOD_UNIFORM_STD, Caffeine::vsl_stream(),
+      VSL_CHECK(vsRngUniform(VSL_RNG_METHOD_UNIFORM_STD, Caffe::vsl_stream(),
           count, (float*)data, this->filler_param_.min(),
           this->filler_param_.max()));
       break;
     case sizeof(double):
-      VSL_CHECK(vdRngUniform(VSL_RNG_METHOD_UNIFORM_STD, Caffeine::vsl_stream(),
+      VSL_CHECK(vdRngUniform(VSL_RNG_METHOD_UNIFORM_STD, Caffe::vsl_stream(),
           count, (double*)data, this->filler_param_.min(),
           this->filler_param_.max()));
       break;
@@ -82,12 +82,12 @@ class GaussianFiller : public Filler<Dtype> {
     switch(sizeof(Dtype)) {
     case sizeof(float):
       VSL_CHECK(vsRngGaussian(VSL_RNG_METHOD_GAUSSIAN_BOXMULLER,
-          Caffeine::vsl_stream(), count, (float*)data,
+          Caffe::vsl_stream(), count, (float*)data,
           this->filler_param_.mean(), this->filler_param_.std()));
       break;
     case sizeof(double):
       VSL_CHECK(vdRngGaussian(VSL_RNG_METHOD_GAUSSIAN_BOXMULLER,
-          Caffeine::vsl_stream(), count, (double*)data,
+          Caffe::vsl_stream(), count, (double*)data,
           this->filler_param_.mean(), this->filler_param_.std()));
       break;
     default:
@@ -114,6 +114,6 @@ Filler<Dtype>* GetFiller(const FillerParameter& param) {
   return (Filler<Dtype>*)(NULL);
 }
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_FILLER_HPP_
+#endif  // CAFFE_FILLER_HPP_
similarity index 85%
rename from src/caffeine/layer.hpp
rename to src/caffe/layer.hpp
index f81535c671df11ef6e4059e5eb2f2c02e6c5b126..d86ccdc58826365786fd67d1cbadc05cf8cfd9ce 100644 (file)
@@ -1,14 +1,14 @@
-#ifndef CAFFEINE_LAYER_H_
-#define CAFFEINE_LAYER_H_
+#ifndef CAFFE_LAYER_H_
+#define CAFFE_LAYER_H_
 
 #include <vector>
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/proto/layer_param.pb.h"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/proto/layer_param.pb.h"
 
 using std::vector;
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 class Layer {
@@ -71,15 +71,15 @@ class Layer {
 template <typename Dtype>
 inline void Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,
     vector<Blob<Dtype>*>* top) {
-  switch(Caffeine::mode()) {
-  case Caffeine::CPU:
+  switch(Caffe::mode()) {
+  case Caffe::CPU:
     Forward_cpu(bottom, top);
     break;
-  case Caffeine::GPU:
+  case Caffe::GPU:
     Forward_gpu(bottom, top);
     break;
   default:
-    LOG(FATAL) << "Unknown caffeine mode.";
+    LOG(FATAL) << "Unknown caffe mode.";
   }
 };
 
@@ -87,16 +87,16 @@ template <typename Dtype>
 inline Dtype Layer<Dtype>::Backward(const vector<Blob<Dtype>*>& top,
     const bool propagate_down,
     vector<Blob<Dtype>*>* bottom) {
-  switch(Caffeine::mode()) {
-  case Caffeine::CPU:
+  switch(Caffe::mode()) {
+  case Caffe::CPU:
     return Backward_cpu(top, propagate_down, bottom);
-  case Caffeine::GPU:
+  case Caffe::GPU:
     return Backward_gpu(top, propagate_down, bottom);
   default:
-    LOG(FATAL) << "Unknown caffeine mode.";
+    LOG(FATAL) << "Unknown caffe mode.";
   }
 };
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_LAYER_H_
+#endif  // CAFFE_LAYER_H_
similarity index 90%
rename from src/caffeine/layers/conv_layer.cpp
rename to src/caffe/layers/conv_layer.cpp
index 8670d81f1c60b606c15e0755bd62de28fe6367b0..c9dc2f62c453ff14458a904dfd0d9cf86f75c506 100644 (file)
@@ -1,10 +1,10 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/util/im2col.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/util/im2col.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/util/math_functions.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void ConvolutionLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -76,13 +76,13 @@ void ConvolutionLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
         WIDTH_, KSIZE_, STRIDE_, col_data);
     // Second, innerproduct with groups
     for (int g = 0; g < GROUP_; ++g) {
-      caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_,
+      caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_,
         (Dtype)1., weight + weight_offset * g, col_data + col_offset * g,
         (Dtype)0., top_data + (*top)[0]->offset(n) + top_offset * g);
     }
     // third, add bias
     if (biasterm_) {
-      caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, NUM_OUTPUT_,
+      caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, NUM_OUTPUT_,
           N_, 1, (Dtype)1., this->blobs_[1].cpu_data(),
           (Dtype*)bias_multiplier_->cpu_data(), (Dtype)1.,
           top_data + (*top)[0]->offset(n));
@@ -106,13 +106,13 @@ void ConvolutionLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
         WIDTH_, KSIZE_, STRIDE_, col_data);
     // Second, innerproduct with groups
     for (int g = 0; g < GROUP_; ++g) {
-      caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_,
+      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_,
         (Dtype)1., weight + weight_offset * g, col_data + col_offset * g,
         (Dtype)0., top_data + (*top)[0]->offset(n) + top_offset * g);
     }
     // third, add bias
     if (biasterm_) {
-      caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, NUM_OUTPUT_,
+      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, NUM_OUTPUT_,
           N_, 1, (Dtype)1., this->blobs_[1].gpu_data(),
           (Dtype*)bias_multiplier_->gpu_data(), (Dtype)1.,
           top_data + (*top)[0]->offset(n));
@@ -137,7 +137,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
     bias_diff = this->blobs_[1].mutable_cpu_diff();
     memset(bias_diff, 0., sizeof(Dtype) * this->blobs_[1].count());
     for (int n = 0; n < NUM_; ++n) {
-      caffeine_cpu_gemv<Dtype>(CblasNoTrans, NUM_OUTPUT_, N_,
+      caffe_cpu_gemv<Dtype>(CblasNoTrans, NUM_OUTPUT_, N_,
         1., top_diff + top[0]->offset(n),
         (Dtype*)bias_multiplier_->cpu_data(), 1., bias_diff);
     }
@@ -154,7 +154,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
         WIDTH_, KSIZE_, STRIDE_, col_data);
     // gradient w.r.t. weight. Note that we will accumulate diffs.
     for (int g = 0; g < GROUP_; ++g) {
-      caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_,
+      caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_,
         (Dtype)1., top_diff + top[0]->offset(n) + top_offset * g,
         col_data + col_offset * g, (Dtype)1.,
         weight_diff + weight_offset * g);
@@ -162,7 +162,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
     // gradient w.r.t. bottom data, if necessary
     if (propagate_down) {
       for (int g = 0; g < GROUP_; ++g) {
-        caffeine_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_,
+        caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_,
           (Dtype)1., weight + weight_offset * g,
           top_diff + top[0]->offset(n) + top_offset * g,
           (Dtype)0., col_diff + col_offset * g);
@@ -193,7 +193,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     CUDA_CHECK(cudaMemset(bias_diff, 0.,
         sizeof(Dtype) * this->blobs_[1].count()));
     for (int n = 0; n < NUM_; ++n) {
-      caffeine_gpu_gemv<Dtype>(CblasNoTrans, NUM_OUTPUT_, N_,
+      caffe_gpu_gemv<Dtype>(CblasNoTrans, NUM_OUTPUT_, N_,
         1., top_diff + top[0]->offset(n),
         (Dtype*)bias_multiplier_->gpu_data(), 1., bias_diff);
     }
@@ -211,7 +211,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
         WIDTH_, KSIZE_, STRIDE_, col_data);
     // gradient w.r.t. weight. Note that we will accumulate diffs.
     for (int g = 0; g < GROUP_; ++g) {
-      caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_,
+      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_,
         (Dtype)1., top_diff + top[0]->offset(n) + top_offset * g,
         col_data + col_offset * g, (Dtype)1.,
         weight_diff + weight_offset * g);
@@ -219,7 +219,7 @@ Dtype ConvolutionLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     // gradient w.r.t. bottom data, if necessary
     if (propagate_down) {
       for (int g = 0; g < GROUP_; ++g) {
-        caffeine_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_,
+        caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_,
           (Dtype)1., weight + weight_offset * g,
           top_diff + top[0]->offset(n) + top_offset * g,
           (Dtype)0., col_diff + col_offset * g);
@@ -234,4 +234,4 @@ Dtype ConvolutionLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 
 INSTANTIATE_CLASS(ConvolutionLayer);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 83%
rename from src/caffeine/layers/dropout_layer.cu
rename to src/caffe/layers/dropout_layer.cu
index 2d9e2600afb6bbfb3e49b6c40ae3f19eff41386d..74627bbcdbcd5105a02ab58684d2e1150fa49c80 100644 (file)
@@ -1,14 +1,14 @@
 #include <algorithm>
 #include <limits>
 
-#include "caffeine/common.hpp"
-#include "caffeine/layer.hpp"
-#include "caffeine/syncedmem.hpp"
-#include "caffeine/vision_layers.hpp"
+#include "caffe/common.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/syncedmem.hpp"
+#include "caffe/vision_layers.hpp"
 
 using std::max;
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void DropoutLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -30,9 +30,9 @@ void DropoutLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
   Dtype* top_data = (*top)[0]->mutable_cpu_data();
   int* mask = (int*)rand_vec_->mutable_cpu_data();
   const int count = bottom[0]->count();
-  if (Caffeine::phase() == Caffeine::TRAIN) {
+  if (Caffe::phase() == Caffe::TRAIN) {
     // Create random numbers
-    viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffeine::vsl_stream(),
+    viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffe::vsl_stream(),
         count, mask, 1. - threshold_);
     for (int i = 0; i < count; ++i) {
       top_data[i] = bottom_data[i] * mask[i] * scale_;
@@ -46,7 +46,7 @@ template <typename Dtype>
 Dtype DropoutLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
     const bool propagate_down,
     vector<Blob<Dtype>*>* bottom) {
-  CHECK(Caffeine::phase() == Caffeine::TRAIN);
+  CHECK(Caffe::phase() == Caffe::TRAIN);
   if (propagate_down) {
     const Dtype* top_diff = top[0]->cpu_diff();
     Dtype* bottom_diff = (*bottom)[0]->mutable_cpu_diff();
@@ -75,11 +75,11 @@ void DropoutLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
   const Dtype* bottom_data = bottom[0]->gpu_data();
   Dtype* top_data = (*top)[0]->mutable_gpu_data();
   const int count = bottom[0]->count();
-  if (Caffeine::phase() == Caffeine::TRAIN) {
-    CURAND_CHECK(curandGenerate(Caffeine::curand_generator(),
+  if (Caffe::phase() == Caffe::TRAIN) {
+    CURAND_CHECK(curandGenerate(Caffe::curand_generator(),
         (unsigned int*)(rand_vec_->mutable_gpu_data()), count));
     // set thresholds
-    DropoutForward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+    DropoutForward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
         count, bottom_data, (unsigned int*)rand_vec_->gpu_data(), uint_thres_, scale_,
         top_data);
     CUDA_POST_KERNEL_CHECK;
@@ -105,13 +105,13 @@ template <typename Dtype>
 Dtype DropoutLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     const bool propagate_down,
     vector<Blob<Dtype>*>* bottom) {
-  CHECK(Caffeine::phase() == Caffeine::TRAIN);
+  CHECK(Caffe::phase() == Caffe::TRAIN);
   if (propagate_down) {
     const Dtype* top_diff = top[0]->gpu_diff();
     Dtype* bottom_diff = (*bottom)[0]->mutable_gpu_diff();
     const unsigned int* mask = (unsigned int*)rand_vec_->gpu_data();
     const int count = (*bottom)[0]->count();
-    DropoutBackward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+    DropoutBackward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
         count, top_diff, mask, uint_thres_, scale_, bottom_diff);
     CUDA_POST_KERNEL_CHECK;
   }
@@ -121,4 +121,4 @@ Dtype DropoutLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 INSTANTIATE_CLASS(DropoutLayer);
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 93%
rename from src/caffeine/layers/im2col_layer.cpp
rename to src/caffe/layers/im2col_layer.cpp
index 9fc62966ecd675b08f14de154e8fa589fd10d1c9..a52829c648dfd6c6f654ff029ce964b0a31e2a0a 100644 (file)
@@ -1,9 +1,9 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/util/im2col.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/common.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/util/im2col.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/common.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void Im2colLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -68,4 +68,4 @@ Dtype Im2colLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 
 INSTANTIATE_CLASS(Im2colLayer);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 79%
rename from src/caffeine/layers/inner_product_layer.cpp
rename to src/caffe/layers/inner_product_layer.cpp
index 2f7af89fa1e38aed6ee2f82c4732dd9d17c5a2ed..3f4d8c53064384a3ba7af6118ab6d5e2ff8f0d8c 100644 (file)
@@ -1,14 +1,14 @@
 #include <mkl.h>
 #include <cublas_v2.h>
 
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/util/math_functions.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void InnerProductLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -53,10 +53,10 @@ void InnerProductLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
   const Dtype* bottom_data = bottom[0]->cpu_data();
   Dtype* top_data = (*top)[0]->mutable_cpu_data();
   const Dtype* weight = this->blobs_[0].cpu_data();
-  caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_, (Dtype)1.,
+  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_, (Dtype)1.,
       bottom_data, weight, (Dtype)0., top_data);
   if (biasterm_) {
-    caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,
+    caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,
         (Dtype*)bias_multiplier_->cpu_data(), this->blobs_[1].cpu_data(),
         (Dtype)1., top_data);
   }
@@ -69,17 +69,17 @@ Dtype InnerProductLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
   const Dtype* top_diff = top[0]->cpu_diff();
   const Dtype* bottom_data = (*bottom)[0]->cpu_data();
   // Gradient with respect to weight
-  caffeine_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_, (Dtype)1.,
+  caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_, (Dtype)1.,
       bottom_data, top_diff, (Dtype)0., this->blobs_[0].mutable_cpu_diff());
   if (biasterm_) {
     // Gradient with respect to bias
-    caffeine_cpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
+    caffe_cpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
         (Dtype*)bias_multiplier_->cpu_data(), (Dtype)0.,
         this->blobs_[1].mutable_cpu_diff());
   }
   if (propagate_down) {
     // Gradient with respect to bottom data
-    caffeine_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_, (Dtype)1.,
+    caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_, (Dtype)1.,
         top_diff, this->blobs_[0].cpu_data(), (Dtype)0.,
         (*bottom)[0]->mutable_cpu_diff());
   }
@@ -92,10 +92,10 @@ void InnerProductLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
   const Dtype* bottom_data = bottom[0]->gpu_data();
   Dtype* top_data = (*top)[0]->mutable_gpu_data();
   const Dtype* weight = this->blobs_[0].gpu_data();
-  caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_, (Dtype)1.,
+  caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, K_, (Dtype)1.,
       bottom_data, weight, (Dtype)0., top_data);
   if (biasterm_) {
-    caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,
+    caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,
         (Dtype*)bias_multiplier_->gpu_data(), this->blobs_[1].gpu_data(),
         (Dtype)1., top_data);
   }
@@ -108,17 +108,17 @@ Dtype InnerProductLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
   const Dtype* top_diff = top[0]->gpu_diff();
   const Dtype* bottom_data = (*bottom)[0]->gpu_data();
   // Gradient with respect to weight
-  caffeine_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_, (Dtype)1.,
+  caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans, K_, N_, M_, (Dtype)1.,
       bottom_data, top_diff, (Dtype)0., this->blobs_[0].mutable_gpu_diff());
   if (biasterm_) {
     // Gradient with respect to bias
-    caffeine_gpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
+    caffe_gpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
         (Dtype*)bias_multiplier_->gpu_data(), (Dtype)0.,
         this->blobs_[1].mutable_gpu_diff());
   }
   if (propagate_down) {
     // Gradient with respect to bottom data
-    caffeine_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_, (Dtype)1.,
+    caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans, M_, K_, N_, (Dtype)1.,
         top_diff, this->blobs_[0].gpu_data(), (Dtype)0.,
         (*bottom)[0]->mutable_gpu_diff());
   }
@@ -127,4 +127,4 @@ Dtype InnerProductLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 
 INSTANTIATE_CLASS(InnerProductLayer);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 80%
rename from src/caffeine/layers/lrn_layer.cpp
rename to src/caffe/layers/lrn_layer.cpp
index 2c62136a8a7112c1682c8e2d5a946dddd2258d31..2d359a4d752807842ba7b572d1596d0acdf6fb0a 100644 (file)
@@ -1,8 +1,8 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/util/math_functions.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void LRNLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -40,34 +40,34 @@ void LRNLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
   // go through the images
   for (int n = 0; n < num_; ++n) {
     // compute the padded square
-    caffeine_sqr(channels_ * height_ * width_,
+    caffe_sqr(channels_ * height_ * width_,
         bottom_data + bottom[0]->offset(n),
         padded_square_data + padded_square.offset(0, pre_pad_));
     // Create the first channel scale
     for (int c = 0; c < size_; ++c) {
-      caffeine_axpy<Dtype>(height_ * width_, alpha_over_size,
+      caffe_axpy<Dtype>(height_ * width_, alpha_over_size,
           padded_square_data + padded_square.offset(0, c),
           scale_data + scale_.offset(n, 0));
     }
     for (int c = 1; c < channels_; ++c) {
       // copy previous scale
-      caffeine_copy<Dtype>(height_ * width_,
+      caffe_copy<Dtype>(height_ * width_,
           scale_data + scale_.offset(n, c - 1),
           scale_data + scale_.offset(n, c));
       // add head
-      caffeine_axpy<Dtype>(height_ * width_, alpha_over_size,
+      caffe_axpy<Dtype>(height_ * width_, alpha_over_size,
           padded_square_data + padded_square.offset(0, c + size_ - 1),
           scale_data + scale_.offset(n, c));
       // subtract tail
-      caffeine_axpy<Dtype>(height_ * width_, -alpha_over_size,
+      caffe_axpy<Dtype>(height_ * width_, -alpha_over_size,
           padded_square_data + padded_square.offset(0, c - 1),
           scale_data + scale_.offset(n, c));
     }
   }
 
   // In the end, compute output
-  caffeine_powx<Dtype>(scale_.count(), scale_data, -beta_, top_data);
-  caffeine_mul<Dtype>(scale_.count(), top_data, bottom_data, top_data);
+  caffe_powx<Dtype>(scale_.count(), scale_data, -beta_, top_data);
+  caffe_mul<Dtype>(scale_.count(), top_data, bottom_data, top_data);
 }
 
 template <typename Dtype>
@@ -87,38 +87,38 @@ Dtype LRNLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
   memset(padded_ratio_data, 0, sizeof(Dtype) * padded_ratio.count());
   Dtype cache_ratio_value = 2. * alpha_ * beta_ / size_;
 
-  caffeine_powx<Dtype>(scale_.count(), scale_data, -beta_, bottom_diff);
-  caffeine_mul<Dtype>(scale_.count(), top_diff, bottom_diff, bottom_diff);
+  caffe_powx<Dtype>(scale_.count(), scale_data, -beta_, bottom_diff);
+  caffe_mul<Dtype>(scale_.count(), top_diff, bottom_diff, bottom_diff);
 
   // go through individual data
   int inverse_pre_pad = size_ - (size_ + 1) / 2;
   for (int n = 0; n < num_; ++n) {
     int block_offset = scale_.offset(n);
     // first, compute diff_i * y_i / s_i
-    caffeine_mul<Dtype>(channels_ * height_ * width_,
+    caffe_mul<Dtype>(channels_ * height_ * width_,
         top_diff + block_offset, top_data + block_offset,
         padded_ratio_data + padded_ratio.offset(0, inverse_pre_pad));
-    caffeine_div<Dtype>(channels_ * height_ * width_,
+    caffe_div<Dtype>(channels_ * height_ * width_,
         padded_ratio_data + padded_ratio.offset(0, inverse_pre_pad),
         scale_data + block_offset,
         padded_ratio_data + padded_ratio.offset(0, inverse_pre_pad));
     // Now, compute the accumulated ratios and the bottom diff
     memset(accum_ratio_data, 0, sizeof(Dtype) * accum_ratio.count());
     for (int c = 0; c < size_ - 1; ++c) {
-      caffeine_axpy<Dtype>(height_ * width_, 1.,
+      caffe_axpy<Dtype>(height_ * width_, 1.,
           padded_ratio_data + padded_ratio.offset(0, c), accum_ratio_data);
     }
     for (int c = 0; c < channels_; ++c) {
-      caffeine_axpy<Dtype>(height_ * width_, 1.,
+      caffe_axpy<Dtype>(height_ * width_, 1.,
           padded_ratio_data + padded_ratio.offset(0, c + size_ - 1),
           accum_ratio_data);
       // compute bottom diff
-      caffeine_mul<Dtype>(height_ * width_,
+      caffe_mul<Dtype>(height_ * width_,
           bottom_data + top[0]->offset(n, c),
           accum_ratio_data, accum_ratio_times_bottom);
-      caffeine_axpy<Dtype>(height_ * width_, -cache_ratio_value,
+      caffe_axpy<Dtype>(height_ * width_, -cache_ratio_value,
           accum_ratio_times_bottom, bottom_diff + top[0]->offset(n,c));
-      caffeine_axpy<Dtype>(height_ * width_, -1.,
+      caffe_axpy<Dtype>(height_ * width_, -1.,
           padded_ratio_data + padded_ratio.offset(0, c), accum_ratio_data);
     }
   }
@@ -128,4 +128,4 @@ Dtype LRNLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
 INSTANTIATE_CLASS(LRNLayer);
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 93%
rename from src/caffeine/layers/lrn_layer.cu
rename to src/caffe/layers/lrn_layer.cu
index 2dc514322bc7abf3af8732a3a6d0de679c7518ab..4f27f3a522ff0f1cb5180f38d79be703849b924d 100644 (file)
@@ -1,8 +1,8 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/util/math_functions.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 __global__ void LRNFillScale(const int nthreads, const Dtype* in,
@@ -72,12 +72,12 @@ void LRNLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
   // We will launch one kernel for each pixel location, and have the kernel
   // go through all the channels.
   int n_threads = num_ * height_ * width_;
-  LRNFillScale<<<CAFFEINE_GET_BLOCKS(n_threads), CAFFEINE_CUDA_NUM_THREADS>>>(
+  LRNFillScale<<<CAFFE_GET_BLOCKS(n_threads), CAFFE_CUDA_NUM_THREADS>>>(
       n_threads, bottom_data, num_, channels_, height_, width_, size_,
       alpha_ / size_, scale_data);
   CUDA_POST_KERNEL_CHECK;
   n_threads = bottom[0]->count();
-  LRNComputeOutput<<<CAFFEINE_GET_BLOCKS(n_threads), CAFFEINE_CUDA_NUM_THREADS>>>(
+  LRNComputeOutput<<<CAFFE_GET_BLOCKS(n_threads), CAFFE_CUDA_NUM_THREADS>>>(
       n_threads, bottom_data, scale_data, -beta_, top_data);
   CUDA_POST_KERNEL_CHECK;
 }
@@ -149,7 +149,7 @@ template <typename Dtype>
 Dtype LRNLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     const bool propagate_down, vector<Blob<Dtype>*>* bottom) {
   int n_threads = num_ * height_ * width_;
-  LRNComputeDiff<<<CAFFEINE_GET_BLOCKS(n_threads), CAFFEINE_CUDA_NUM_THREADS>>>(
+  LRNComputeDiff<<<CAFFE_GET_BLOCKS(n_threads), CAFFE_CUDA_NUM_THREADS>>>(
       n_threads, (*bottom)[0]->gpu_data(), top[0]->gpu_data(),
       scale_.gpu_data(), top[0]->gpu_diff(), num_, channels_, height_, width_,
       size_, -beta_, Dtype(2. * alpha_ * beta_ / size_),
@@ -160,4 +160,4 @@ Dtype LRNLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 
 INSTANTIATE_CLASS(LRNLayer);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 79%
rename from src/caffeine/layers/neuron_layer.cpp
rename to src/caffe/layers/neuron_layer.cpp
index 4cac434263f92937e82917c5a119d08052579336..e30626d3e77e6369b2c7dbdbfd3b95aef6331728 100644 (file)
@@ -1,7 +1,7 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void NeuronLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -14,4 +14,4 @@ void NeuronLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
 
 INSTANTIATE_CLASS(NeuronLayer);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 94%
rename from src/caffeine/layers/padding_layer.cu
rename to src/caffe/layers/padding_layer.cu
index 53bd1f50b8eef20cb5ec330c7a8535e0ad455a47..24aa97c49215bf7b8f4282a6abe0a0825aae1c91 100644 (file)
@@ -1,9 +1,9 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
 
 #include <iostream>
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void PaddingLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
@@ -90,7 +90,7 @@ void PaddingLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
   const int count = bottom[0]->count();
   // First, set all data to be zero for the boundary pixels
   CUDA_CHECK(cudaMemset(top_data, 0, sizeof(Dtype) * (*top)[0]->count()));
-  PaddingForward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+  PaddingForward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
       count, bottom_data, top_data, NUM_, CHANNEL_, HEIGHT_IN_, WIDTH_IN_,
       PAD_);
   CUDA_POST_KERNEL_CHECK;
@@ -123,7 +123,7 @@ Dtype PaddingLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     const Dtype* top_diff = top[0]->gpu_diff();
     Dtype* bottom_diff = (*bottom)[0]->mutable_gpu_diff();
     const int count = (*bottom)[0]->count();
-    PaddingBackward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+    PaddingBackward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
         count, top_diff, bottom_diff, NUM_, CHANNEL_, HEIGHT_IN_, WIDTH_IN_,
         PAD_);
     CUDA_POST_KERNEL_CHECK;
@@ -134,4 +134,4 @@ Dtype PaddingLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 INSTANTIATE_CLASS(PaddingLayer);
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 88%
rename from src/caffeine/layers/relu_layer.cu
rename to src/caffe/layers/relu_layer.cu
index 12a9b6c9514bdadda1aba278cc915a5d3f1aa4f3..3e3ca9a0d2e465a146388b406ce76c4aca8a2955 100644 (file)
@@ -1,10 +1,10 @@
-#include "caffeine/layer.hpp"
-#include "caffeine/vision_layers.hpp"
+#include "caffe/layer.hpp"
+#include "caffe/vision_layers.hpp"
 #include <algorithm>
 
 using std::max;
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void ReLULayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
@@ -47,7 +47,7 @@ void ReLULayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
   const Dtype* bottom_data = bottom[0]->gpu_data();
   Dtype* top_data = (*top)[0]->mutable_gpu_data();
   const int count = bottom[0]->count();
-  ReLUForward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+  ReLUForward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
       count, bottom_data, top_data);
 }
 
@@ -69,7 +69,7 @@ Dtype ReLULayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
     const Dtype* top_diff = top[0]->gpu_diff();
     Dtype* bottom_diff = (*bottom)[0]->mutable_gpu_diff();
     const int count = (*bottom)[0]->count();
-    ReLUBackward<Dtype><<<CAFFEINE_GET_BLOCKS(count), CAFFEINE_CUDA_NUM_THREADS>>>(
+    ReLUBackward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
         count, top_diff, bottom_data, bottom_diff);
   }
   return Dtype(0);
@@ -78,4 +78,4 @@ Dtype ReLULayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
 INSTANTIATE_CLASS(ReLULayer);
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 99%
rename from src/caffeine/proto/layer_param.proto
rename to src/caffe/proto/layer_param.proto
index c4965510f0869f5387d2cab41c8ea0ab6e0b7865..e3cd0b45b2020c88bacc919a9d4dcb58f41b9da4 100644 (file)
@@ -1,4 +1,4 @@
-package caffeine;
+package caffe;
 
 message BlobProto {
   optional int32 num = 1 [default = 0];
similarity index 93%
rename from src/caffeine/syncedmem.cpp
rename to src/caffe/syncedmem.cpp
index f57b9fc20a7660b0f2764c3614b570ec805381e1..cafcee786941b57c3aa5f477993c82ded0a2cab3 100644 (file)
@@ -1,10 +1,10 @@
 #include <cstring>
 #include <cuda_runtime.h>
 
-#include "caffeine/common.hpp"
-#include "caffeine/syncedmem.hpp"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 SyncedMemory::~SyncedMemory() {
   if (cpu_ptr_) {
@@ -80,5 +80,5 @@ void* SyncedMemory::mutable_gpu_data() {
 }
 
 
-}  // namespace caffeine
+}  // namespace caffe
 
similarity index 82%
rename from src/caffeine/syncedmem.hpp
rename to src/caffe/syncedmem.hpp
index b067bdebbc32fbb82d91304ddb3da5cca0dbcc35..c217691cb660f75106bde3834466017ce3985152 100644 (file)
@@ -1,7 +1,7 @@
-#ifndef CAFFEINE_SYNCEDMEM_HPP
-#define CAFFEINE_SYNCEDMEM_HPP
+#ifndef CAFFE_SYNCEDMEM_HPP
+#define CAFFE_SYNCEDMEM_HPP
 
-namespace caffeine {
+namespace caffe {
 
 class SyncedMemory {
  public:
@@ -26,6 +26,6 @@ class SyncedMemory {
   SyncedHead head_;
 };  // class SyncedMemory
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_SYNCEDMEM_HPP_
+#endif  // CAFFE_SYNCEDMEM_HPP_
similarity index 93%
rename from src/caffeine/test/test_blob.cpp
rename to src/caffe/test/test_blob.cpp
index e2daec58882d1d870d2943d1a53c1e1653bf5c4d..126d873b85ab12bf3fa0a1f49365d14d70579c45 100644 (file)
@@ -2,13 +2,13 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/common.hpp"
-#include "caffeine/blob.hpp"
-#include "caffeine/filler.hpp"
+#include "caffe/common.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/filler.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
   
 template <typename Dtype>
 class BlobSimpleTest : public ::testing::Test {
similarity index 67%
rename from src/caffeine/test/test_caffeine_main.hpp
rename to src/caffe/test/test_caffe_main.hpp
index 536dca9546f701f567b9e4612e0a9b2191342e08..0e58268dff7f2d5e7084b4c99b8b0a68a7fe8cc4 100644 (file)
@@ -1,7 +1,7 @@
-// The main caffeine test code. Your test cpp code should include this hpp
+// The main caffe test code. Your test cpp code should include this hpp
 // to allow a main function to be compiled into the binary.
-#ifndef CAFFEINE_TEST_TEST_CAFFEINE_MAIN_HPP_
-#define CAFFEINE_TEST_TEST_CAFFEINE_MAIN_HPP_
+#ifndef CAFFE_TEST_TEST_CAFFE_MAIN_HPP_
+#define CAFFE_TEST_TEST_CAFFE_MAIN_HPP_
 
 #include <cstdlib>
 #include <cstdio>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
-namespace caffeine {
+namespace caffe {
 
-cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+cudaDeviceProp CAFFE_TEST_CUDA_PROP;
 
-}  // namespace caffeine
+}  // namespace caffe
 
-using namespace caffeine;
+using namespace caffe;
 using namespace std;
 
 int main(int argc, char** argv) {
@@ -35,9 +35,9 @@ int main(int argc, char** argv) {
   }
   cudaGetDevice(&device);
   cout << "Current device id: " << device << endl;
-  cudaGetDeviceProperties(&CAFFEINE_TEST_CUDA_PROP, device);
+  cudaGetDeviceProperties(&CAFFE_TEST_CUDA_PROP, device);
   // invoke the test.
   return RUN_ALL_TESTS();
 }
 
-#endif  // CAFFEINE_TEST_TEST_CAFFEINE_MAIN_HPP_
+#endif  // CAFFE_TEST_TEST_CAFFE_MAIN_HPP_
similarity index 55%
rename from src/caffeine/test/test_common.cpp
rename to src/caffe/test/test_common.cpp
index 8f7db2c6043a76f7f0df125a71fe94a854e29488..466ada7e184f0fa6886d231d1cae441438770bd0 100644 (file)
@@ -2,45 +2,45 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/common.hpp"
-#include "caffeine/syncedmem.hpp"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 class CommonTest : public ::testing::Test {};
 
 TEST_F(CommonTest, TestCublasHandler) {
   int cuda_device_id;
   CUDA_CHECK(cudaGetDevice(&cuda_device_id));
-  EXPECT_TRUE(Caffeine::cublas_handle());
+  EXPECT_TRUE(Caffe::cublas_handle());
 }
 
 TEST_F(CommonTest, TestVslStream) {
-  EXPECT_TRUE(Caffeine::vsl_stream());
+  EXPECT_TRUE(Caffe::vsl_stream());
 }
 
 TEST_F(CommonTest, TestBrewMode) {
-  EXPECT_EQ(Caffeine::mode(), Caffeine::CPU);
-  Caffeine::set_mode(Caffeine::GPU);
-  EXPECT_EQ(Caffeine::mode(), Caffeine::GPU);
+  EXPECT_EQ(Caffe::mode(), Caffe::CPU);
+  Caffe::set_mode(Caffe::GPU);
+  EXPECT_EQ(Caffe::mode(), Caffe::GPU);
 }
 
 TEST_F(CommonTest, TestPhase) {
-  EXPECT_EQ(Caffeine::phase(), Caffeine::TRAIN);
-  Caffeine::set_phase(Caffeine::TEST);
-  EXPECT_EQ(Caffeine::phase(), Caffeine::TEST);
+  EXPECT_EQ(Caffe::phase(), Caffe::TRAIN);
+  Caffe::set_phase(Caffe::TEST);
+  EXPECT_EQ(Caffe::phase(), Caffe::TEST);
 }
 
 TEST_F(CommonTest, TestRandSeedCPU) {
   SyncedMemory data_a(10 * sizeof(int));
   SyncedMemory data_b(10 * sizeof(int));
-  Caffeine::set_random_seed(1701);
-  viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffeine::vsl_stream(),
+  Caffe::set_random_seed(1701);
+  viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffe::vsl_stream(),
         10, (int*)data_a.mutable_cpu_data(), 0.5);
-  Caffeine::set_random_seed(1701);
-  viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffeine::vsl_stream(),
+  Caffe::set_random_seed(1701);
+  viRngBernoulli(VSL_RNG_METHOD_BERNOULLI_ICDF, Caffe::vsl_stream(),
         10, (int*)data_b.mutable_cpu_data(), 0.5);
   for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(((const int*)(data_a.cpu_data()))[i],
@@ -52,11 +52,11 @@ TEST_F(CommonTest, TestRandSeedCPU) {
 TEST_F(CommonTest, TestRandSeedGPU) {
   SyncedMemory data_a(10 * sizeof(unsigned int));
   SyncedMemory data_b(10 * sizeof(unsigned int));
-  Caffeine::set_random_seed(1701);
-  CURAND_CHECK(curandGenerate(Caffeine::curand_generator(),
+  Caffe::set_random_seed(1701);
+  CURAND_CHECK(curandGenerate(Caffe::curand_generator(),
         (unsigned int*)data_a.mutable_gpu_data(), 10));
-  Caffeine::set_random_seed(1701);
-  CURAND_CHECK(curandGenerate(Caffeine::curand_generator(),
+  Caffe::set_random_seed(1701);
+  CURAND_CHECK(curandGenerate(Caffe::curand_generator(),
         (unsigned int*)data_b.mutable_gpu_data(), 10));
   for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(((const unsigned int*)(data_a.cpu_data()))[i],
@@ -65,4 +65,4 @@ TEST_F(CommonTest, TestRandSeedGPU) {
 }
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 91%
rename from src/caffeine/test/test_convolution_layer.cpp
rename to src/caffe/test/test_convolution_layer.cpp
index 15fcfa2ea28b19c33b676a4bd9a76635a008849b..d57d3aed1a6ee9db5497bcf05c741bd8d219929f 100644 (file)
@@ -2,17 +2,17 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
  
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
 
 template <typename Dtype>
 class ConvolutionLayerTest : public ::testing::Test {
@@ -81,7 +81,7 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) {
   shared_ptr<Layer<TypeParam> > layer(
       new ConvolutionLayer<TypeParam>(layer_param));
   layer->SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer->Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // After the convolution, the output should all have output values 27.1
   const TypeParam* top_data = this->blob_top_->cpu_data();
@@ -90,7 +90,7 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) {
     EXPECT_LE(top_data[i], 27.1 + 1e-4);
   }
   // Test GPU
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   layer->Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // After the convolution, the output should all have output values 27.1
   top_data = this->blob_top_->cpu_data();
@@ -118,7 +118,7 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolutionGroup) {
   shared_ptr<Layer<TypeParam> > layer(
       new ConvolutionLayer<TypeParam>(layer_param));
   layer->SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer->Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // After the convolution, the output should all have output values 9.1
   const TypeParam* top_data = this->blob_top_->cpu_data();
@@ -127,7 +127,7 @@ TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolutionGroup) {
     EXPECT_LE(top_data[i], 9.1 + 1e-4);
   }
   // Test GPU
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   layer->Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // After the convolution, the output should all have output values 9.1
   top_data = this->blob_top_->cpu_data();
@@ -143,7 +143,7 @@ TYPED_TEST(ConvolutionLayerTest, TestCPUGradient) {
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
   layer_param.set_num_output(2);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   ConvolutionLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
@@ -154,7 +154,7 @@ TYPED_TEST(ConvolutionLayerTest, TestGPUGradient) {
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
   layer_param.set_num_output(2);
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   ConvolutionLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
similarity index 96%
rename from src/caffeine/test/test_filler.cpp
rename to src/caffe/test/test_filler.cpp
index 6a66f8e59ee7639436c6414367e0d25c86d492e3..e0074191969773eb5c94529baff48ced315370eb 100644 (file)
@@ -2,11 +2,11 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/filler.hpp"
+#include "caffe/filler.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 typedef ::testing::Types<float, double> Dtypes;
 
similarity index 95%
rename from src/caffeine/test/test_gradient_check_util.hpp
rename to src/caffe/test/test_gradient_check_util.hpp
index 6b7733693ac0153c2ca31e37cb4ac6f3b76758fa..475fd438f67665679ae14e6465a3ac5bf82450d8 100644 (file)
@@ -1,15 +1,15 @@
-#ifndef CAFFEINE_TEST_GRADIENT_CHECK_UTIL_H_
-#define CAFFEINE_TEST_GRADIENT_CHECK_UTIL_H_
+#ifndef CAFFE_TEST_GRADIENT_CHECK_UTIL_H_
+#define CAFFE_TEST_GRADIENT_CHECK_UTIL_H_
 
 #include <algorithm>
 #include <cmath>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
-#include "caffeine/layer.hpp"
+#include "caffe/layer.hpp"
 
 using std::max;
 
-namespace caffeine {
+namespace caffe {
 
 // The gradient checker adds a L2 normalization loss function on top of the
 // top blobs, and checks the gradient.
@@ -79,7 +79,7 @@ void GradientChecker<Dtype>::CheckGradientSingle(Layer<Dtype>& layer,
     // go through the values
     for (int feat_id = 0; feat_id < current_blob->count(); ++feat_id) {
       // First, obtain the original data
-      Caffeine::set_random_seed(seed_);
+      Caffe::set_random_seed(seed_);
       layer.Forward(bottom, &top);
       Dtype computed_objective = GetObjAndGradient(top, top_id, top_data_id);
       // Get any additional loss from the layer
@@ -87,13 +87,13 @@ void GradientChecker<Dtype>::CheckGradientSingle(Layer<Dtype>& layer,
       Dtype computed_gradient = current_blob->cpu_diff()[feat_id];
       // compute score by adding stepsize
       current_blob->mutable_cpu_data()[feat_id] += stepsize_;
-      Caffeine::set_random_seed(seed_);
+      Caffe::set_random_seed(seed_);
       layer.Forward(bottom, &top);
       Dtype positive_objective = GetObjAndGradient(top, top_id, top_data_id);
       positive_objective += layer.Backward(top, true, &bottom);
       // compute score by subtracting stepsize
       current_blob->mutable_cpu_data()[feat_id] -= stepsize_ * 2;
-      Caffeine::set_random_seed(seed_);
+      Caffe::set_random_seed(seed_);
       layer.Forward(bottom, &top);
       Dtype negative_objective = GetObjAndGradient(top, top_id, top_data_id);
       negative_objective += layer.Backward(top, true, &bottom);
@@ -164,6 +164,6 @@ Dtype GradientChecker<Dtype>::GetObjAndGradient(vector<Blob<Dtype>*>& top,
   return loss;
 }
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_TEST_GRADIENT_CHECK_UTIL_H_
+#endif  // CAFFE_TEST_GRADIENT_CHECK_UTIL_H_
similarity index 86%
rename from src/caffeine/test/test_im2col_layer.cpp
rename to src/caffe/test/test_im2col_layer.cpp
index 52361358781f06e2b5df3d78951a68152bb38619..0145cf7072f4afb39b1f349982a12f49ecfe8af6 100644 (file)
@@ -2,17 +2,17 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
   
 template <typename Dtype>
 class Im2colLayerTest : public ::testing::Test {
@@ -54,7 +54,7 @@ TYPED_TEST(Im2colLayerTest, TestCPU) {
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
   Im2colLayer<TypeParam> layer(layer_param);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // We are lazy and will only check the top left block
@@ -69,7 +69,7 @@ TYPED_TEST(Im2colLayerTest, TestGPU) {
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
   Im2colLayer<TypeParam> layer(layer_param);
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   // We are lazy and will only check the top left block
@@ -83,7 +83,7 @@ TYPED_TEST(Im2colLayerTest, TestCPUGradient) {
   LayerParameter layer_param;
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   Im2colLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
@@ -93,7 +93,7 @@ TYPED_TEST(Im2colLayerTest, TestGPUGradient) {
   LayerParameter layer_param;
   layer_param.set_kernelsize(3);
   layer_param.set_stride(2);
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   Im2colLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
similarity index 87%
rename from src/caffeine/test/test_innerproduct_layer.cpp
rename to src/caffe/test/test_innerproduct_layer.cpp
index 357e6b3a9cdf0fe5cb4cd2fb970736161897930d..48061ebba49812cf055d01083d2fe0401595c8de 100644 (file)
@@ -2,17 +2,17 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
   
 template <typename Dtype>
 class InnerProductLayerTest : public ::testing::Test {
@@ -51,7 +51,7 @@ TYPED_TEST(InnerProductLayerTest, TestSetUp) {
 
 TYPED_TEST(InnerProductLayerTest, TestCPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer_param.set_num_output(10);
   layer_param.mutable_weight_filler()->set_type("uniform");
   layer_param.mutable_bias_filler()->set_type("uniform");
@@ -69,9 +69,9 @@ TYPED_TEST(InnerProductLayerTest, TestCPU) {
 }
 
 TYPED_TEST(InnerProductLayerTest, TestGPU) {
-       if (sizeof(TypeParam) == 4 || CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+       if (sizeof(TypeParam) == 4 || CAFFE_TEST_CUDA_PROP.major >= 2) {
          LayerParameter layer_param;
-         Caffeine::set_mode(Caffeine::GPU);
+         Caffe::set_mode(Caffe::GPU);
          layer_param.set_num_output(10);
          layer_param.mutable_weight_filler()->set_type("uniform");
          layer_param.mutable_bias_filler()->set_type("uniform");
@@ -93,7 +93,7 @@ TYPED_TEST(InnerProductLayerTest, TestGPU) {
 
 TYPED_TEST(InnerProductLayerTest, TestCPUGradient) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer_param.set_num_output(10);
   layer_param.mutable_weight_filler()->set_type("uniform");
   layer_param.mutable_bias_filler()->set_type("uniform");
@@ -105,9 +105,9 @@ TYPED_TEST(InnerProductLayerTest, TestCPUGradient) {
 }
 
 TYPED_TEST(InnerProductLayerTest, TestGPUGradient) {
-  if (sizeof(TypeParam) == 4 || CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+  if (sizeof(TypeParam) == 4 || CAFFE_TEST_CUDA_PROP.major >= 2) {
     LayerParameter layer_param;
-    Caffeine::set_mode(Caffeine::GPU);
+    Caffe::set_mode(Caffe::GPU);
     layer_param.set_num_output(10);
     layer_param.mutable_weight_filler()->set_type("uniform");
     layer_param.mutable_bias_filler()->set_type("uniform");
similarity index 91%
rename from src/caffeine/test/test_lrn_layer.cpp
rename to src/caffe/test/test_lrn_layer.cpp
index f8cfb21877937794f320ebd1cc903f7511c0e2e6..ec328bb6116ad715292817c598992e5cb4f1d258 100644 (file)
@@ -4,20 +4,20 @@
 #include <iostream>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
 using std::min;
 using std::max;
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
   
 template <typename Dtype>
 class LRNLayerTest : public ::testing::Test {
@@ -26,7 +26,7 @@ class LRNLayerTest : public ::testing::Test {
       : blob_bottom_(new Blob<Dtype>()),
         blob_top_(new Blob<Dtype>()) {};
   virtual void SetUp() {
-    Caffeine::set_random_seed(1701);
+    Caffe::set_random_seed(1701);
     blob_bottom_->Reshape(2, 7, 3, 3);
     // fill the values
     FillerParameter filler_param;
@@ -91,7 +91,7 @@ TYPED_TEST(LRNLayerTest, TestSetup) {
 TYPED_TEST(LRNLayerTest, TestCPUForward) {
   LayerParameter layer_param;
   LRNLayer<TypeParam> layer(layer_param);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   Blob<TypeParam> top_reference;
@@ -108,7 +108,7 @@ TYPED_TEST(LRNLayerTest, TestCPUForward) {
 TYPED_TEST(LRNLayerTest, TestGPUForward) {
   LayerParameter layer_param;
   LRNLayer<TypeParam> layer(layer_param);
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   Blob<TypeParam> top_reference;
@@ -126,7 +126,7 @@ TYPED_TEST(LRNLayerTest, TestCPUGradient) {
   LayerParameter layer_param;
   LRNLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   for (int i = 0; i < this->blob_top_->count(); ++i) {
@@ -143,7 +143,7 @@ TYPED_TEST(LRNLayerTest, TestGPUGradient) {
   LayerParameter layer_param;
   LRNLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-2);
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
   for (int i = 0; i < this->blob_top_->count(); ++i) {
similarity index 86%
rename from src/caffeine/test/test_neuron_layer.cpp
rename to src/caffe/test/test_neuron_layer.cpp
index f73198b4c2d38c752c3fe1583caf0e8c6e32a88a..aeb09b110974895ba9518452b073cb8ddf422563 100644 (file)
@@ -2,17 +2,17 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
   
 template <typename Dtype>
 class NeuronLayerTest : public ::testing::Test {
@@ -39,7 +39,7 @@ TYPED_TEST_CASE(NeuronLayerTest, Dtypes);
 
 TYPED_TEST(NeuronLayerTest, TestReLUCPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   ReLULayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -55,7 +55,7 @@ TYPED_TEST(NeuronLayerTest, TestReLUCPU) {
 
 TYPED_TEST(NeuronLayerTest, TestReLUGradientCPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   ReLULayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-3, 1701, 0., 0.01);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
@@ -64,7 +64,7 @@ TYPED_TEST(NeuronLayerTest, TestReLUGradientCPU) {
 
 TYPED_TEST(NeuronLayerTest, TestReLUGPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   ReLULayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -80,7 +80,7 @@ TYPED_TEST(NeuronLayerTest, TestReLUGPU) {
 
 TYPED_TEST(NeuronLayerTest, TestReLUGradientGPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::GPU);
+  Caffe::set_mode(Caffe::GPU);
   ReLULayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-3, 1701, 0., 0.01);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
@@ -89,8 +89,8 @@ TYPED_TEST(NeuronLayerTest, TestReLUGradientGPU) {
 
 TYPED_TEST(NeuronLayerTest, TestDropoutCPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
-  Caffeine::set_phase(Caffeine::TRAIN);
+  Caffe::set_mode(Caffe::CPU);
+  Caffe::set_phase(Caffe::TRAIN);
   DropoutLayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -108,7 +108,7 @@ TYPED_TEST(NeuronLayerTest, TestDropoutCPU) {
 
 TYPED_TEST(NeuronLayerTest, TestDropoutGradientCPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   DropoutLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-3);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
@@ -117,8 +117,8 @@ TYPED_TEST(NeuronLayerTest, TestDropoutGradientCPU) {
 
 TYPED_TEST(NeuronLayerTest, TestDropoutCPUTestPhase) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::CPU);
-  Caffeine::set_phase(Caffeine::TEST);
+  Caffe::set_mode(Caffe::CPU);
+  Caffe::set_phase(Caffe::TEST);
   DropoutLayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -136,8 +136,8 @@ TYPED_TEST(NeuronLayerTest, TestDropoutCPUTestPhase) {
 
 TYPED_TEST(NeuronLayerTest, TestDropoutGPU) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::GPU);
-  Caffeine::set_phase(Caffeine::TRAIN);
+  Caffe::set_mode(Caffe::GPU);
+  Caffe::set_phase(Caffe::TRAIN);
   DropoutLayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -154,9 +154,9 @@ TYPED_TEST(NeuronLayerTest, TestDropoutGPU) {
 
 
 TYPED_TEST(NeuronLayerTest, TestDropoutGradientGPU) {
-  if (CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+  if (CAFFE_TEST_CUDA_PROP.major >= 2) {
     LayerParameter layer_param;
-    Caffeine::set_mode(Caffeine::GPU);
+    Caffe::set_mode(Caffe::GPU);
     DropoutLayer<TypeParam> layer(layer_param);
     GradientChecker<TypeParam> checker(1e-2, 1e-3);
     // it is too expensive to call curand multiple times, so we don't do an
@@ -170,8 +170,8 @@ TYPED_TEST(NeuronLayerTest, TestDropoutGradientGPU) {
 
 TYPED_TEST(NeuronLayerTest, TestDropoutGPUTestPhase) {
   LayerParameter layer_param;
-  Caffeine::set_mode(Caffeine::GPU);
-  Caffeine::set_phase(Caffeine::TEST);
+  Caffe::set_mode(Caffe::GPU);
+  Caffe::set_phase(Caffe::TEST);
   DropoutLayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
similarity index 85%
rename from src/caffeine/test/test_padding_layer.cpp
rename to src/caffe/test/test_padding_layer.cpp
index 896c66ed27fd12107614670d3350d5c856c1fecb..13468e118cc7e9b4db6d4e592a2caa1ea09ea19c 100644 (file)
@@ -2,17 +2,17 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/common.hpp"
-#include "caffeine/filler.hpp"
-#include "caffeine/vision_layers.hpp"
-#include "caffeine/test/test_gradient_check_util.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/common.hpp"
+#include "caffe/filler.hpp"
+#include "caffe/vision_layers.hpp"
+#include "caffe/test/test_gradient_check_util.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
   
 template <typename Dtype>
 class PaddingLayerTest : public ::testing::Test {
@@ -40,7 +40,7 @@ TYPED_TEST_CASE(PaddingLayerTest, Dtypes);
 TYPED_TEST(PaddingLayerTest, TestCPU) {
   LayerParameter layer_param;
   layer_param.set_pad(1);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   PaddingLayer<TypeParam> layer(layer_param);
   layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
   layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -63,17 +63,17 @@ TYPED_TEST(PaddingLayerTest, TestCPU) {
 TYPED_TEST(PaddingLayerTest, TestCPUGrad) {
   LayerParameter layer_param;
   layer_param.set_pad(1);
-  Caffeine::set_mode(Caffeine::CPU);
+  Caffe::set_mode(Caffe::CPU);
   PaddingLayer<TypeParam> layer(layer_param);
   GradientChecker<TypeParam> checker(1e-2, 1e-3);
   checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
 }
 
 TYPED_TEST(PaddingLayerTest, TestGPU) {
-  if (CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+  if (CAFFE_TEST_CUDA_PROP.major >= 2) {
     LayerParameter layer_param;
     layer_param.set_pad(1);
-    Caffeine::set_mode(Caffeine::GPU);
+    Caffe::set_mode(Caffe::GPU);
     PaddingLayer<TypeParam> layer(layer_param);
     layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));
     layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));
@@ -97,10 +97,10 @@ TYPED_TEST(PaddingLayerTest, TestGPU) {
 }
 
 TYPED_TEST(PaddingLayerTest, TestGPUGrad) {
-  if (CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+  if (CAFFE_TEST_CUDA_PROP.major >= 2) {
     LayerParameter layer_param;
     layer_param.set_pad(1);
-    Caffeine::set_mode(Caffeine::GPU);
+    Caffe::set_mode(Caffe::GPU);
     PaddingLayer<TypeParam> layer(layer_param);
     GradientChecker<TypeParam> checker(1e-2, 1e-3);
     checker.CheckGradientExhaustive(layer, this->blob_bottom_vec_, this->blob_top_vec_);
diff --git a/src/caffe/test/test_platform.cpp b/src/caffe/test/test_platform.cpp
new file mode 100644 (file)
index 0000000..c0ebb0a
--- /dev/null
@@ -0,0 +1,39 @@
+#include <cstdlib>
+#include <cstdio>
+#include <iostream>
+
+#include <cuda_runtime.h>
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+#include "caffe/test/test_caffe_main.hpp"
+
+namespace caffe {
+
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
+
+class PlatformTest : public ::testing::Test {};
+
+TEST_F(PlatformTest, TestInitialization) {
+  printf("Major revision number:         %d\n",  CAFFE_TEST_CUDA_PROP.major);
+  printf("Minor revision number:         %d\n",  CAFFE_TEST_CUDA_PROP.minor);
+  printf("Name:                          %s\n",  CAFFE_TEST_CUDA_PROP.name);
+  printf("Total global memory:           %lu\n",  CAFFE_TEST_CUDA_PROP.totalGlobalMem);
+  printf("Total shared memory per block: %lu\n",  CAFFE_TEST_CUDA_PROP.sharedMemPerBlock);
+  printf("Total registers per block:     %d\n",  CAFFE_TEST_CUDA_PROP.regsPerBlock);
+  printf("Warp size:                     %d\n",  CAFFE_TEST_CUDA_PROP.warpSize);
+  printf("Maximum memory pitch:          %lu\n",  CAFFE_TEST_CUDA_PROP.memPitch);
+  printf("Maximum threads per block:     %d\n",  CAFFE_TEST_CUDA_PROP.maxThreadsPerBlock);
+  for (int i = 0; i < 3; ++i)
+    printf("Maximum dimension %d of block:  %d\n", i, CAFFE_TEST_CUDA_PROP.maxThreadsDim[i]);
+  for (int i = 0; i < 3; ++i)
+    printf("Maximum dimension %d of grid:   %d\n", i, CAFFE_TEST_CUDA_PROP.maxGridSize[i]);
+  printf("Clock rate:                    %d\n",  CAFFE_TEST_CUDA_PROP.clockRate);
+  printf("Total constant memory:         %lu\n",  CAFFE_TEST_CUDA_PROP.totalConstMem);
+  printf("Texture alignment:             %lu\n",  CAFFE_TEST_CUDA_PROP.textureAlignment);
+  printf("Concurrent copy and execution: %s\n",  (CAFFE_TEST_CUDA_PROP.deviceOverlap ? "Yes" : "No"));
+  printf("Number of multiprocessors:     %d\n",  CAFFE_TEST_CUDA_PROP.multiProcessorCount);
+  printf("Kernel execution timeout:      %s\n",  (CAFFE_TEST_CUDA_PROP.kernelExecTimeoutEnabled ? "Yes" : "No"));
+  EXPECT_TRUE(true);
+}
+
+}  // namespace caffe
similarity index 86%
rename from src/caffeine/test/test_protobuf.cpp
rename to src/caffe/test/test_protobuf.cpp
index 331c84c22ee43997c0024e26bf1491e70118a4f5..51be49d5f493d00cf88c0e53188a5038731f8a2a 100644 (file)
@@ -4,10 +4,10 @@
 
 #include <google/protobuf/text_format.h>
 #include "gtest/gtest.h"
-#include "caffeine/test/test_caffeine_main.hpp"
-#include "caffeine/proto/layer_param.pb.h"
+#include "caffe/test/test_caffe_main.hpp"
+#include "caffe/proto/layer_param.pb.h"
 
-namespace caffeine {
+namespace caffe {
   
 class ProtoTest : public ::testing::Test {};
 
similarity index 94%
rename from src/caffeine/test/test_syncedmem.cpp
rename to src/caffe/test/test_syncedmem.cpp
index a99552d8732a41ab99bb8bde6e19abe8f5bf51e8..e002ef383330a1668dca8a6712f84fbd5b33b464 100644 (file)
@@ -2,12 +2,12 @@
 #include <cuda_runtime.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/common.hpp"
-#include "caffeine/syncedmem.hpp"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 class SyncedMemoryTest : public ::testing::Test {};
 
similarity index 75%
rename from src/caffeine/test/test_util_blas.cpp
rename to src/caffe/test/test_util_blas.cpp
index e9c09bb353a91b316ce49a91fccb0c053a82cebc..7addad1eb30c5449cd9a2681a189e6b78f41c9f9 100644 (file)
@@ -4,14 +4,14 @@
 #include <cublas_v2.h>
 
 #include "gtest/gtest.h"
-#include "caffeine/blob.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/blob.hpp"
+#include "caffe/util/math_functions.hpp"
 
-#include "caffeine/test/test_caffeine_main.hpp"
+#include "caffe/test/test_caffe_main.hpp"
 
-namespace caffeine {
+namespace caffe {
 
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
+extern cudaDeviceProp CAFFE_TEST_CUDA_PROP;
 
 typedef ::testing::Types<float, double> Dtypes;
 
@@ -31,14 +31,14 @@ TYPED_TEST(GemmTest, TestGemm) {
   memcpy(A.mutable_cpu_data(), data, 6 * sizeof(TypeParam));
   memcpy(B.mutable_cpu_data(), data, 12 * sizeof(TypeParam));
 
-  if (sizeof(TypeParam) == 4 || CAFFEINE_TEST_CUDA_PROP.major >= 2) {
+  if (sizeof(TypeParam) == 4 || CAFFE_TEST_CUDA_PROP.major >= 2) {
     //[1,2,3; 4 5 6] * [1,2,3,4; 5,6,7,8; 9,10,11,12];
-    caffeine_cpu_gemm<TypeParam>(CblasNoTrans, CblasNoTrans, 2, 4, 3, 1.,
+    caffe_cpu_gemm<TypeParam>(CblasNoTrans, CblasNoTrans, 2, 4, 3, 1.,
         A.cpu_data(), B.cpu_data(), 0., C.mutable_cpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
     }
-    caffeine_gpu_gemm<TypeParam>(CblasNoTrans, CblasNoTrans, 2, 4, 3, 1.,
+    caffe_gpu_gemm<TypeParam>(CblasNoTrans, CblasNoTrans, 2, 4, 3, 1.,
         A.gpu_data(), B.gpu_data(), 0., C.mutable_gpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
@@ -47,12 +47,12 @@ TYPED_TEST(GemmTest, TestGemm) {
     // Test when we have a transposed A
     A.Reshape(1,1,3,2);
     memcpy(A.mutable_cpu_data(), A_reshape_data, 6 * sizeof(TypeParam));
-    caffeine_cpu_gemm<TypeParam>(CblasTrans, CblasNoTrans, 2, 4, 3, 1.,
+    caffe_cpu_gemm<TypeParam>(CblasTrans, CblasNoTrans, 2, 4, 3, 1.,
         A.cpu_data(), B.cpu_data(), 0., C.mutable_cpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
     }
-    caffeine_gpu_gemm<TypeParam>(CblasTrans, CblasNoTrans, 2, 4, 3, 1.,
+    caffe_gpu_gemm<TypeParam>(CblasTrans, CblasNoTrans, 2, 4, 3, 1.,
         A.gpu_data(), B.gpu_data(), 0., C.mutable_gpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
@@ -61,12 +61,12 @@ TYPED_TEST(GemmTest, TestGemm) {
     // Test when we have a transposed A and a transposed B too
     B.Reshape(1,1,4,3);
     memcpy(B.mutable_cpu_data(), B_reshape_data, 12 * sizeof(TypeParam));
-    caffeine_cpu_gemm<TypeParam>(CblasTrans, CblasTrans, 2, 4, 3, 1.,
+    caffe_cpu_gemm<TypeParam>(CblasTrans, CblasTrans, 2, 4, 3, 1.,
         A.cpu_data(), B.cpu_data(), 0., C.mutable_cpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
     }
-    caffeine_gpu_gemm<TypeParam>(CblasTrans, CblasTrans, 2, 4, 3, 1.,
+    caffe_gpu_gemm<TypeParam>(CblasTrans, CblasTrans, 2, 4, 3, 1.,
         A.gpu_data(), B.gpu_data(), 0., C.mutable_gpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
@@ -75,12 +75,12 @@ TYPED_TEST(GemmTest, TestGemm) {
     // Test when we have a transposed B
     A.Reshape(1,1,2,3);
     memcpy(A.mutable_cpu_data(), data, 6 * sizeof(TypeParam));
-    caffeine_cpu_gemm<TypeParam>(CblasNoTrans, CblasTrans, 2, 4, 3, 1.,
+    caffe_cpu_gemm<TypeParam>(CblasNoTrans, CblasTrans, 2, 4, 3, 1.,
         A.cpu_data(), B.cpu_data(), 0., C.mutable_cpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
     }
-    caffeine_gpu_gemm<TypeParam>(CblasNoTrans, CblasTrans, 2, 4, 3, 1.,
+    caffe_gpu_gemm<TypeParam>(CblasNoTrans, CblasTrans, 2, 4, 3, 1.,
         A.gpu_data(), B.gpu_data(), 0., C.mutable_gpu_data());
     for (int i = 0; i < 8; ++i) {
       EXPECT_EQ(C.cpu_data()[i], result[i]);
@@ -101,13 +101,13 @@ TYPED_TEST(GemmTest, TestGemv) {
   memcpy(A.mutable_cpu_data(), data, 6 * sizeof(TypeParam));
   memcpy(x.mutable_cpu_data(), data, 3 * sizeof(TypeParam));
 
-  if (sizeof(TypeParam) == 4 || CAFFEINE_TEST_CUDA_PROP.major >= 2) {
-    caffeine_cpu_gemv<TypeParam>(CblasNoTrans, 2, 3, 1., A.cpu_data(),
+  if (sizeof(TypeParam) == 4 || CAFFE_TEST_CUDA_PROP.major >= 2) {
+    caffe_cpu_gemv<TypeParam>(CblasNoTrans, 2, 3, 1., A.cpu_data(),
         x.cpu_data(), 0., y.mutable_cpu_data());
     for (int i = 0; i < 2; ++i) {
       EXPECT_EQ(y.cpu_data()[i], result_2[i]);
     }
-    caffeine_gpu_gemv<TypeParam>(CblasNoTrans, 2, 3, 1., A.gpu_data(),
+    caffe_gpu_gemv<TypeParam>(CblasNoTrans, 2, 3, 1., A.gpu_data(),
         x.gpu_data(), 0., y.mutable_gpu_data());
     for (int i = 0; i < 2; ++i) {
       EXPECT_EQ(y.cpu_data()[i], result_2[i]);
@@ -115,12 +115,12 @@ TYPED_TEST(GemmTest, TestGemv) {
 
     // Test transpose case
     memcpy(y.mutable_cpu_data(), data, 2 * sizeof(TypeParam));
-    caffeine_cpu_gemv<TypeParam>(CblasTrans, 2, 3, 1., A.cpu_data(),
+    caffe_cpu_gemv<TypeParam>(CblasTrans, 2, 3, 1., A.cpu_data(),
         y.cpu_data(), 0., x.mutable_cpu_data());
     for (int i = 0; i < 3; ++i) {
       EXPECT_EQ(x.cpu_data()[i], result_3[i]);
     }
-    caffeine_gpu_gemv<TypeParam>(CblasTrans, 2, 3, 1., A.gpu_data(),
+    caffe_gpu_gemv<TypeParam>(CblasTrans, 2, 3, 1., A.gpu_data(),
         y.gpu_data(), 0., x.mutable_gpu_data());
     for (int i = 0; i < 3; ++i) {
       EXPECT_EQ(x.cpu_data()[i], result_3[i]);
similarity index 96%
rename from src/caffeine/util/im2col.cpp
rename to src/caffe/util/im2col.cpp
index 11c3bf6e8b2c9d2caca3c256919785eba75acf05..89bfba7d94f4c0f46732755d3aa9fd58c316c45c 100644 (file)
@@ -2,9 +2,9 @@
 #include <cstdlib>
 #include <cstring>
 
-#include "caffeine/util/im2col.hpp"
+#include "caffe/util/im2col.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void im2col_cpu(const Dtype* data_im, const int channels,
@@ -64,4 +64,4 @@ template void col2im_cpu<double>(const double* data_col, const int channels,
     const int height, const int width, const int psize, const int stride,
     double* data_im);
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 93%
rename from src/caffeine/util/im2col.cu
rename to src/caffe/util/im2col.cu
index 03c1dcab717aa73aabec2406d31e1bbff642f86a..aef684284bce029e9aae0475d73679ce1de39db1 100644 (file)
@@ -2,10 +2,10 @@
 #include <cstdlib>
 #include <cstring>
 
-#include "caffeine/common.hpp"
-#include "caffeine/util/im2col.hpp"
+#include "caffe/common.hpp"
+#include "caffe/util/im2col.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 __global__ void im2col_gpu_kernel(const int n, const Dtype* data_im,
@@ -40,7 +40,7 @@ void im2col_gpu(const Dtype* data_im, const int channels,
   int height_col = (height - ksize) / stride + 1;
   int width_col = (width - ksize) / stride + 1;
   int num_kernels = channels * height_col * width_col;
-  im2col_gpu_kernel<Dtype><<<CAFFEINE_GET_BLOCKS(num_kernels), CAFFEINE_CUDA_NUM_THREADS>>>(
+  im2col_gpu_kernel<Dtype><<<CAFFE_GET_BLOCKS(num_kernels), CAFFE_CUDA_NUM_THREADS>>>(
     num_kernels, data_im, height, width, ksize, stride, height_col, width_col,
     data_col);
   CUDA_POST_KERNEL_CHECK;
@@ -88,7 +88,7 @@ void col2im_gpu(const Dtype* data_col, const int channels,
   int num_kernels = channels * height * width;
   // To avoid involving atomic operations, we will launch one kernel per
   // bottom dimension, and then in the kernel add up the top dimensions.
-  col2im_gpu_kernel<Dtype><<<CAFFEINE_GET_BLOCKS(num_kernels), CAFFEINE_CUDA_NUM_THREADS>>>(
+  col2im_gpu_kernel<Dtype><<<CAFFE_GET_BLOCKS(num_kernels), CAFFE_CUDA_NUM_THREADS>>>(
       num_kernels, data_col, height, width, channels, ksize, stride,
       height_col, width_col, data_im);
   CUDA_POST_KERNEL_CHECK;
@@ -104,4 +104,4 @@ template void col2im_gpu<double>(const double* data_col, const int channels,
     double* data_im);
 
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 82%
rename from src/caffeine/util/im2col.hpp
rename to src/caffe/util/im2col.hpp
index f6349909f7ac15999d52cea4b25eb03412ec6a4e..164b84047d635adc0e2e98b3741788c2410b1c97 100644 (file)
@@ -1,7 +1,7 @@
-#ifndef _CAFFEINE_UTIL__IM2COL_HPP_
-#define _CAFFEINE_UTIL_IM2COL_HPP_
+#ifndef _CAFFE_UTIL__IM2COL_HPP_
+#define _CAFFE_UTIL_IM2COL_HPP_
 
-namespace caffeine {
+namespace caffe {
 
 template <typename Dtype>
 void im2col_cpu(const Dtype* data_im, const int channels,
@@ -23,6 +23,6 @@ void col2im_gpu(const Dtype* data_col, const int channels,
     const int height, const int width, const int psize, const int stride,
     Dtype* data_im);
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_UTIL_IM2COL_HPP_
+#endif  // CAFFE_UTIL_IM2COL_HPP_
similarity index 64%
rename from src/caffeine/util/math_functions.cpp
rename to src/caffe/util/math_functions.cpp
index e85825b9a583ed0561c903a52f21c6fcd3dd7fba..f503b83caf7b631e08b711d691524bac86be9882 100644 (file)
@@ -1,12 +1,12 @@
 #include <mkl.h>
 #include <cublas_v2.h>
-#include "caffeine/common.hpp"
-#include "caffeine/util/math_functions.hpp"
+#include "caffe/common.hpp"
+#include "caffe/util/math_functions.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 template<>
-void caffeine_cpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
+void caffe_cpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const float alpha, const float* A, const float* B, const float beta,
     float* C) {
@@ -17,7 +17,7 @@ void caffeine_cpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
 }
 
 template<>
-void caffeine_cpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
+void caffe_cpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const double alpha, const double* A, const double* B, const double beta,
     double* C) {
@@ -28,7 +28,7 @@ void caffeine_cpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
 }
 
 template <>
-void caffeine_gpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
+void caffe_gpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const float alpha, const float* A, const float* B, const float beta,
     float* C) {
@@ -39,12 +39,12 @@ void caffeine_gpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
       (TransA == CblasNoTrans) ? CUBLAS_OP_N : CUBLAS_OP_T;
   cublasOperation_t cuTransB =
       (TransB == CblasNoTrans) ? CUBLAS_OP_N : CUBLAS_OP_T;
-  CUBLAS_CHECK(cublasSgemm(Caffeine::cublas_handle(), cuTransB, cuTransA,
+  CUBLAS_CHECK(cublasSgemm(Caffe::cublas_handle(), cuTransB, cuTransA,
       N, M, K, &alpha, B, ldb, A, lda, &beta, C, N));  
 }
 
 template <>
-void caffeine_gpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
+void caffe_gpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const double alpha, const double* A, const double* B, const double beta,
     double* C) {
@@ -55,94 +55,94 @@ void caffeine_gpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
       (TransA == CblasNoTrans) ? CUBLAS_OP_N : CUBLAS_OP_T;
   cublasOperation_t cuTransB =
       (TransB == CblasNoTrans) ? CUBLAS_OP_N : CUBLAS_OP_T;
-  CUBLAS_CHECK(cublasDgemm(Caffeine::cublas_handle(), cuTransB, cuTransA,
+  CUBLAS_CHECK(cublasDgemm(Caffe::cublas_handle(), cuTransB, cuTransA,
       N, M, K, &alpha, B, ldb, A, lda, &beta, C, N));  
 }
 
 template <>
-void caffeine_cpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,
+void caffe_cpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,
     const int N, const float alpha, const float* A, const float* x,
     const float beta, float* y) {
   cblas_sgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);
 }
 
 template <>
-void caffeine_cpu_gemv<double>(const CBLAS_TRANSPOSE TransA, const int M,
+void caffe_cpu_gemv<double>(const CBLAS_TRANSPOSE TransA, const int M,
     const int N, const double alpha, const double* A, const double* x,
     const double beta, double* y) {
   cblas_dgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);
 }
 
 template <>
-void caffeine_gpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,
+void caffe_gpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,
     const int N, const float alpha, const float* A, const float* x,
     const float beta, float* y) {
   cublasOperation_t cuTransA =
       (TransA == CblasNoTrans) ? CUBLAS_OP_T : CUBLAS_OP_N;
-  CUBLAS_CHECK(cublasSgemv(Caffeine::cublas_handle(), cuTransA, N, M, &alpha,
+  CUBLAS_CHECK(cublasSgemv(Caffe::cublas_handle(), cuTransA, N, M, &alpha,
       A, N, x, 1, &beta, y, 1));
 }
 
 template <>
-void caffeine_gpu_gemv<double>(const CBLAS_TRANSPOSE TransA, const int M,
+void caffe_gpu_gemv<double>(const CBLAS_TRANSPOSE TransA, const int M,
     const int N, const double alpha, const double* A, const double* x,
     const double beta, double* y) {
   cublasOperation_t cuTransA =
       (TransA == CblasNoTrans) ? CUBLAS_OP_T : CUBLAS_OP_N;
-  CUBLAS_CHECK(cublasDgemv(Caffeine::cublas_handle(), cuTransA, N, M, &alpha,
+  CUBLAS_CHECK(cublasDgemv(Caffe::cublas_handle(), cuTransA, N, M, &alpha,
       A, N, x, 1, &beta, y, 1));
 }
 
 template <>
-void caffeine_axpy<float>(const int N, const float alpha, const float* X,
+void caffe_axpy<float>(const int N, const float alpha, const float* X,
     float* Y) { cblas_saxpy(N, alpha, X, 1, Y, 1); }
 
 template <>
-void caffeine_axpy<double>(const int N, const double alpha, const double* X,
+void caffe_axpy<double>(const int N, const double alpha, const double* X,
     double* Y) { cblas_daxpy(N, alpha, X, 1, Y, 1); }
 
 template <>
-void caffeine_copy<float>(const int N, const float* X, float* Y) {
+void caffe_copy<float>(const int N, const float* X, float* Y) {
   cblas_scopy(N, X, 1, Y, 1);
 }
 
 template <>
-void caffeine_copy<double>(const int N, const double* X, double* Y) {
+void caffe_copy<double>(const int N, const double* X, double* Y) {
   cblas_dcopy(N, X, 1, Y, 1);
 }
 
 template <>
-void caffeine_sqr<float>(const int n, const float* a, float* y){
+void caffe_sqr<float>(const int n, const float* a, float* y){
   vsSqr(n, a, y);
 }
 
 template <>
-void caffeine_sqr<double>(const int n, const double* a, double* y) {
+void caffe_sqr<double>(const int n, const double* a, double* y) {
   vdSqr(n, a, y);
 }
 
 template <>
-void caffeine_mul<float>(const int n, const float* a, const float* b,
+void caffe_mul<float>(const int n, const float* a, const float* b,
     float* y) { vsMul(n, a, b, y); }
 
 template <>
-void caffeine_mul<double>(const int n, const double* a, const double* b,
+void caffe_mul<double>(const int n, const double* a, const double* b,
     double* y) { vdMul(n, a, b, y); }
 
 template <>
-void caffeine_div<float>(const int n, const float* a, const float* b,
+void caffe_div<float>(const int n, const float* a, const float* b,
     float* y) { vsDiv(n, a, b, y); }
 
 template <>
-void caffeine_div<double>(const int n, const double* a, const double* b,
+void caffe_div<double>(const int n, const double* a, const double* b,
     double* y) { vdDiv(n, a, b, y); }
 
 template <>
-void caffeine_powx<float>(const int n, const float* a, const float b,
+void caffe_powx<float>(const int n, const float* a, const float b,
     float* y) { vsPowx(n, a, b, y); }
 
 template <>
-void caffeine_powx<double>(const int n, const double* a, const double b,
+void caffe_powx<double>(const int n, const double* a, const double b,
     double* y) { vdPowx(n, a, b, y); }
 
-}  // namespace caffeine
+}  // namespace caffe
similarity index 57%
rename from src/caffeine/util/math_functions.hpp
rename to src/caffe/util/math_functions.hpp
index 257b61c668aaee406f876c173e427a953e2e1a37..60a43104c01dd031c18de3a576350ef5337538cf 100644 (file)
@@ -1,15 +1,15 @@
-#ifndef CAFFEINE_UTIL_MATH_FUNCTIONS_H_
-#define CAFFEINE_UTIL_MATH_FUNCTIONS_H_
+#ifndef CAFFE_UTIL_MATH_FUNCTIONS_H_
+#define CAFFE_UTIL_MATH_FUNCTIONS_H_
 
 #include <mkl.h>
 #include <cublas_v2.h>
 
-namespace caffeine {
+namespace caffe {
 
 // Decaf gemm provides a simpler interface to the gemm functions, with the
 // limitation that the data has to be contiguous in memory.
 template <typename Dtype>
-void caffeine_cpu_gemm(const CBLAS_TRANSPOSE TransA,
+void caffe_cpu_gemm(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const Dtype alpha, const Dtype* A, const Dtype* B, const Dtype beta,
     Dtype* C);
@@ -18,41 +18,41 @@ void caffeine_cpu_gemm(const CBLAS_TRANSPOSE TransA,
 // gemm function - following the c convention and calling the fortran-order
 // gpu code under the hood.
 template <typename Dtype>
-void caffeine_gpu_gemm(const CBLAS_TRANSPOSE TransA,
+void caffe_gpu_gemm(const CBLAS_TRANSPOSE TransA,
     const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
     const Dtype alpha, const Dtype* A, const Dtype* B, const Dtype beta,
     Dtype* C);
 
 template <typename Dtype>
-void caffeine_cpu_gemv(const CBLAS_TRANSPOSE TransA, const int M, const int N,
+void caffe_cpu_gemv(const CBLAS_TRANSPOSE TransA, const int M, const int N,
     const Dtype alpha, const Dtype* A, const Dtype* x, const Dtype beta,
     Dtype* y);
 
 template <typename Dtype>
-void caffeine_gpu_gemv(const CBLAS_TRANSPOSE TransA, const int M, const int N,
+void caffe_gpu_gemv(const CBLAS_TRANSPOSE TransA, const int M, const int N,
     const Dtype alpha, const Dtype* A, const Dtype* x, const Dtype beta,
     Dtype* y);
 
 template <typename Dtype>
-void caffeine_axpy(const int N, const Dtype alpha, const Dtype* X,
+void caffe_axpy(const int N, const Dtype alpha, const Dtype* X,
     Dtype* Y);
 
 template <typename Dtype>
-void caffeine_copy(const int N, const Dtype *X, Dtype *Y);
+void caffe_copy(const int N, const Dtype *X, Dtype *Y);
 
 template <typename Dtype>
-void caffeine_sqr(const int N, const Dtype* a, Dtype* y);
+void caffe_sqr(const int N, const Dtype* a, Dtype* y);
 
 template <typename Dtype>
-void caffeine_mul(const int N, const Dtype* a, const Dtype* b, Dtype* y);
+void caffe_mul(const int N, const Dtype* a, const Dtype* b, Dtype* y);
 
 template <typename Dtype>
-void caffeine_div(const int N, const Dtype* a, const Dtype* b, Dtype* y);
+void caffe_div(const int N, const Dtype* a, const Dtype* b, Dtype* y);
 
 template <typename Dtype>
-void caffeine_powx(const int n, const Dtype* a, const Dtype b, Dtype* y);
+void caffe_powx(const int n, const Dtype* a, const Dtype b, Dtype* y);
 
-}  // namespace caffeine
+}  // namespace caffe
 
 
-#endif  // CAFFEINE_UTIL_MATH_FUNCTIONS_H_
+#endif  // CAFFE_UTIL_MATH_FUNCTIONS_H_
similarity index 97%
rename from src/caffeine/vision_layers.hpp
rename to src/caffe/vision_layers.hpp
index e609f0c61790a88f74edbe5952b3f0fe78e185e4..35d199130b11ff07525fe8f247fbcb1b1ee935c7 100644 (file)
@@ -1,9 +1,9 @@
-#ifndef CAFFEINE_VISION_LAYERS_HPP_
-#define CAFFEINE_VISION_LAYERS_HPP_
+#ifndef CAFFE_VISION_LAYERS_HPP_
+#define CAFFE_VISION_LAYERS_HPP_
 
-#include "caffeine/layer.hpp"
+#include "caffe/layer.hpp"
 
-namespace caffeine {
+namespace caffe {
 
 // The neuron layer is a specific type of layers that just works on single
 // celements.
@@ -193,7 +193,7 @@ class ConvolutionLayer : public Layer<Dtype> {
   int N_;
 };
 
-}  // namespace caffeine
+}  // namespace caffe
 
-#endif  // CAFFEINE_VISION_LAYERS_HPP_
+#endif  // CAFFE_VISION_LAYERS_HPP_
 
diff --git a/src/caffeine/test/test_platform.cpp b/src/caffeine/test/test_platform.cpp
deleted file mode 100644 (file)
index ada7e0e..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <cstdlib>
-#include <cstdio>
-#include <iostream>
-
-#include <cuda_runtime.h>
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include "caffeine/test/test_caffeine_main.hpp"
-
-namespace caffeine {
-
-extern cudaDeviceProp CAFFEINE_TEST_CUDA_PROP;
-
-class PlatformTest : public ::testing::Test {};
-
-TEST_F(PlatformTest, TestInitialization) {
-  printf("Major revision number:         %d\n",  CAFFEINE_TEST_CUDA_PROP.major);
-  printf("Minor revision number:         %d\n",  CAFFEINE_TEST_CUDA_PROP.minor);
-  printf("Name:                          %s\n",  CAFFEINE_TEST_CUDA_PROP.name);
-  printf("Total global memory:           %lu\n",  CAFFEINE_TEST_CUDA_PROP.totalGlobalMem);
-  printf("Total shared memory per block: %lu\n",  CAFFEINE_TEST_CUDA_PROP.sharedMemPerBlock);
-  printf("Total registers per block:     %d\n",  CAFFEINE_TEST_CUDA_PROP.regsPerBlock);
-  printf("Warp size:                     %d\n",  CAFFEINE_TEST_CUDA_PROP.warpSize);
-  printf("Maximum memory pitch:          %lu\n",  CAFFEINE_TEST_CUDA_PROP.memPitch);
-  printf("Maximum threads per block:     %d\n",  CAFFEINE_TEST_CUDA_PROP.maxThreadsPerBlock);
-  for (int i = 0; i < 3; ++i)
-    printf("Maximum dimension %d of block:  %d\n", i, CAFFEINE_TEST_CUDA_PROP.maxThreadsDim[i]);
-  for (int i = 0; i < 3; ++i)
-    printf("Maximum dimension %d of grid:   %d\n", i, CAFFEINE_TEST_CUDA_PROP.maxGridSize[i]);
-  printf("Clock rate:                    %d\n",  CAFFEINE_TEST_CUDA_PROP.clockRate);
-  printf("Total constant memory:         %lu\n",  CAFFEINE_TEST_CUDA_PROP.totalConstMem);
-  printf("Texture alignment:             %lu\n",  CAFFEINE_TEST_CUDA_PROP.textureAlignment);
-  printf("Concurrent copy and execution: %s\n",  (CAFFEINE_TEST_CUDA_PROP.deviceOverlap ? "Yes" : "No"));
-  printf("Number of multiprocessors:     %d\n",  CAFFEINE_TEST_CUDA_PROP.multiProcessorCount);
-  printf("Kernel execution timeout:      %s\n",  (CAFFEINE_TEST_CUDA_PROP.kernelExecTimeoutEnabled ? "Yes" : "No"));
-  EXPECT_TRUE(true);
-}
-
-}  // namespace caffeine