├── ReadMe.md
├── get_features.cpp
├── sc_load.m
├── test_caffe_manual.cpp
├── test_caffe_manual_output.log
├── train_mnist_99.57.log
└── train_mnist_99.58.log


/ReadMe.md:
--------------------------------------------------------------------------------
  1 | ##Caffe使用教程
  2 | by Shicai Yang（[@星空下的巫师](http://weibo.com/shicaiyang)）on 2015/08/06
  3 | 
  4 | ### 初始化网络
  5 | 
  6 |     #include "caffe/caffe.hpp"
  7 |     #include <string>
  8 |     #include <vector>
  9 |     using namespace caffe;
 10 |     
 11 |     char *proto = "H:\\Models\\Caffe\\deploy.prototxt"; /* 加载CaffeNet的配置 */
 12 |     Phase phase = TEST; /* or TRAIN */
 13 |     Caffe::set_mode(Caffe::CPU);
 14 |     // Caffe::set_mode(Caffe::GPU);
 15 |     // Caffe::SetDevice(0);
 16 |     
 17 |     //! Note: 后文所有提到的net，都是这个net
 18 |     boost::shared_ptr< Net<float> > net(new caffe::Net<float>(proto, phase));
 19 |     
 20 | ### 加载已训练好的模型
 21 | 
 22 |     char *model = "H:\\Models\\Caffe\\bvlc_reference_caffenet.caffemodel";    
 23 |     net->CopyTrainedLayersFrom(model);
 24 |     
 25 | ### 读取模型中的每层的结构配置参数
 26 | 
 27 |     char *model = "H:\\Models\\Caffe\\bvlc_reference_caffenet.caffemodel";
 28 |     NetParameter param;
 29 |     ReadNetParamsFromBinaryFileOrDie(model, &param);
 30 |     int num_layers = param.layer_size();
 31 |     for (int i = 0; i < num_layers; ++i)
 32 |     {
 33 |         // 结构配置参数:name，type，kernel size，pad，stride等
 34 |         LOG(ERROR) << "Layer " << i << ":" << param.layer(i).name() << "\t" << param.layer(i).type();
 35 |         if (param.layer(i).type() == "Convolution")
 36 |         {
 37 |             ConvolutionParameter conv_param = param.layer(i).convolution_param();
 38 |             LOG(ERROR) << "\t\tkernel size: " << conv_param.kernel_size()
 39 |                 << ", pad: " << conv_param.pad()
 40 |                 << ", stride: " << conv_param.stride();
 41 |         }
 42 |     }
 43 |     
 44 | ### 读取图像均值
 45 |     
 46 |     char *mean_file = "H:\\Models\\Caffe\\imagenet_mean.binaryproto";
 47 |     Blob<float> image_mean;
 48 |     BlobProto blob_proto;
 49 |     const float *mean_ptr;
 50 |     unsigned int num_pixel;
 51 |     
 52 |     bool succeed = ReadProtoFromBinaryFile(mean_file, &blob_proto);
 53 |     if (succeed)
 54 |     {
 55 |         image_mean.FromProto(blob_proto);
 56 |         num_pixel = image_mean.count(); /* NCHW=1x3x256x256=196608 */
 57 |         mean_ptr = (const float *) image_mean.cpu_data();
 58 |     }
 59 |     
 60 | ### 根据指定数据，前向传播网络
 61 |     //! Note: data_ptr指向已经处理好（去均值的，符合网络输入图像的长宽和Batch Size）的数据
 62 |     void caffe_forward(boost::shared_ptr< Net<float> > & net, float *data_ptr)
 63 |     {
 64 |         Blob<float>* input_blobs = net->input_blobs()[0];
 65 |         switch (Caffe::mode())
 66 |         {
 67 |         case Caffe::CPU:
 68 |             memcpy(input_blobs->mutable_cpu_data(), data_ptr,
 69 |                 sizeof(float) * input_blobs->count());
 70 |             break;
 71 |         case Caffe::GPU:
 72 |             cudaMemcpy(input_blobs->mutable_gpu_data(), data_ptr,
 73 |                 sizeof(float) * input_blobs->count(), cudaMemcpyHostToDevice);
 74 |             break;
 75 |         default:
 76 |             LOG(FATAL) << "Unknown Caffe mode.";
 77 |         } 
 78 |         net->ForwardPrefilled();
 79 |     }
 80 |     
 81 | ### 根据Feature层的名字获取其在网络中的Index
 82 | 
 83 |     //! Note: Net的Blob是指，每个层的输出数据，即Feature Maps
 84 |     // char *query_blob_name = "conv1";
 85 |     unsigned int get_blob_index(boost::shared_ptr< Net<float> > & net, char *query_blob_name)
 86 |     {
 87 |         std::string str_query(query_blob_name);    
 88 |         vector< string > const & blob_names = net->blob_names();
 89 |         for( unsigned int i = 0; i != blob_names.size(); ++i ) 
 90 |         { 
 91 |             if( str_query == blob_names[i] ) 
 92 |             { 
 93 |                 return i;
 94 |             } 
 95 |         }
 96 |         LOG(FATAL) << "Unknown blob name: " << str_query;
 97 |     }
 98 |     
 99 | ### 读取网络指定Feature层数据
100 | 
101 |     //! Note: 根据CaffeNet的deploy.prototxt文件，该Net共有15个Blob，从data一直到prob    
102 |     char *query_blob_name = "conv1"; /* data, conv1, pool1, norm1, fc6, prob, etc */
103 |     unsigned int blob_id = get_blob_index(net, query_blob_name);
104 |     
105 |     boost::shared_ptr<Blob<float> > blob = net->blobs()[blob_id];
106 |     unsigned int num_data = blob->count(); /* NCHW=10x96x55x55 */
107 |     const float *blob_ptr = (const float *) blob->cpu_data();
108 | 
109 | ### 根据文件列表，获取特征，并存为二进制文件
110 | 
111 | 详见**get_features.cpp**文件：
112 | > 主要包括三个步骤
113 | - 生成文件列表，格式与训练用的类似，每行一个图像
114 | 包括文件全路径、空格、标签（没有的话，可以置0）
115 | - 根据train_val或者deploy的prototxt，改写生成feat.prototxt
116 | 主要是将输入层改为image_data层，最后加上prob和argmax（为了输出概率和Top1/5预测标签）
117 | - 根据指定参数，运行程序后会生成若干个二进制文件，可以用MATLAB读取数据，进行分析
118 | 
119 | 
120 |     
121 | ### 根据Layer的名字获取其在网络中的Index
122 | 
123 |     //! Note: Layer包括神经网络所有层，比如，CaffeNet共有23层
124 |     // char *query_layer_name = "conv1";
125 |     unsigned int get_layer_index(boost::shared_ptr< Net<float> > & net, char *query_layer_name)
126 |     {
127 |         std::string str_query(query_layer_name);    
128 |         vector< string > const & layer_names = net->layer_names();
129 |         for( unsigned int i = 0; i != layer_names.size(); ++i ) 
130 |         { 
131 |             if( str_query == layer_names[i] ) 
132 |             { 
133 |                 return i;
134 |             } 
135 |         }
136 |         LOG(FATAL) << "Unknown layer name: " << str_query;
137 |     }
138 |     
139 | ### 读取指定Layer的权重数据
140 | 
141 |     //! Note: 不同于Net的Blob是Feature Maps，Layer的Blob是指Conv和FC等层的Weight和Bias
142 |     char *query_layer_name = "conv1";
143 |     const float *weight_ptr, *bias_ptr;
144 |     unsigned int layer_id = get_layer_index(net, query_layer_name);
145 |     boost::shared_ptr<Layer<float> > layer = net->layers()[layer_id];
146 |     std::vector<boost::shared_ptr<Blob<float>  >> blobs = layer->blobs();
147 |     if (blobs.size() > 0)
148 |     {
149 |         weight_ptr = (const float *) blobs[0]->cpu_data();
150 |         bias_ptr = (const float *) blobs[1]->cpu_data();
151 |     }
152 |     
153 |     //! Note: 训练模式下，读取指定Layer的梯度数据，与此相似，唯一的区别是将cpu_data改为cpu_diff
154 |     
155 | ### 修改某层的Weight数据
156 |     
157 |     const float* data_ptr;          /* 指向待写入数据的指针， 源数据指针*/
158 |     float* weight_ptr = NULL;       /* 指向网络中某层权重的指针，目标数据指针*/
159 |     unsigned int data_size;         /* 待写入的数据量 */
160 |     char *layer_name = "conv1";     /* 需要修改的Layer名字 */
161 |     
162 |     unsigned int layer_id = get_layer_index(net, query_layer_name);    
163 |     boost::shared_ptr<Blob<float> > blob = net->layers()[layer_id]->blobs()[0];
164 |     
165 |     CHECK(data_size == blob->count());
166 |     switch (Caffe::mode())
167 |     {
168 |     case Caffe::CPU:
169 |         weight_ptr = blob->mutable_cpu_data();
170 |         break;
171 |     case Caffe::GPU:
172 |         weight_ptr = blob->mutable_gpu_data();
173 |         break;
174 |     default:
175 |         LOG(FATAL) << "Unknown Caffe mode";
176 |     }
177 |     caffe_copy(blob->count(), data_ptr, weight_ptr);
178 |     
179 |     //! Note: 训练模式下，手动修改指定Layer的梯度数据，与此相似
180 |     // mutable_cpu_data改为mutable_cpu_diff，mutable_gpu_data改为mutable_gpu_diff
181 | 
182 | ### 保存新的模型
183 | 
184 |     char* weights_file = "bvlc_reference_caffenet_new.caffemodel";
185 |     NetParameter net_param;
186 |     net->ToProto(&net_param, false);
187 |     WriteProtoToBinaryFile(net_param, weights_file);
188 |     
189 | 


--------------------------------------------------------------------------------
/get_features.cpp:
--------------------------------------------------------------------------------
  1 | /***
  2 |  usage:
  3 |  get_features.exe feat.prototxt H:\Models\Caffe\bvlc_reference_caffenet.caffemodel 6 
  4 |  conv1,fc7,prob,argmax conv1.dat,fc7.dat,prob.dat,argmax.dat GPU 0 
  5 | 
  6 |  for feat.prototxt, see the following example:
  7 |  name: "CaffeNet"
  8 |  state {
  9 |     phase: TEST
 10 |  }
 11 |  layer {
 12 |      name: "data"
 13 |      type: "ImageData"
 14 |      top: "data"
 15 |      top: "label"
 16 |      transform_param {
 17 |          mirror: false
 18 |          crop_size: 227
 19 |          mean_file: "imagenet_mean.binaryproto"
 20 |      }
 21 |      image_data_param {
 22 |          source: "file_list.txt"
 23 |          batch_size: 1
 24 |          new_height: 256
 25 |          new_width: 256
 26 |      }
 27 |  }
 28 |  layer {
 29 |      name: "conv1"
 30 |      type: "Convolution"
 31 |      bottom: "data"
 32 |      top: "conv1"
 33 |      convolution_param {
 34 |          num_output: 96
 35 |          kernel_size: 11
 36 |          stride: 4
 37 |      }
 38 |  }
 39 |  #################################################################################
 40 |  ######some lines are ignored here for simplicity, complete them by yourself######
 41 |  #################################################################################
 42 |  layer {
 43 |      name: "fc8"
 44 |      type: "InnerProduct"
 45 |      bottom: "fc7"
 46 |      top: "fc8"
 47 |      inner_product_param {
 48 |         num_output: 1000
 49 |      }
 50 |  }
 51 |  layer {
 52 |      name: "prob"
 53 |      type: "Softmax"
 54 |      bottom: "fc8"
 55 |      top: "prob"
 56 |  }
 57 |  layer {
 58 |      name: "argmax"
 59 |      type: "ArgMax"
 60 |      bottom: "prob"
 61 |      top: "argmax"
 62 |      argmax_param {
 63 |         top_k: 1
 64 |      }
 65 |  }
 66 | 
 67 |  for file_list.txt, see the following example:
 68 |      H:\Data\ILSVRC2012\n01440764\n01440764_18.JPEG 0
 69 |      H:\Data\ILSVRC2012\n01440764\n01440764_297.JPEG 0
 70 |      H:\Data\ILSVRC2012\n01443537\n01443537_395.JPEG 1
 71 |      H:\Data\ILSVRC2012\n01443537\n01443537_693.JPEG 1
 72 |      H:\Data\ILSVRC2012\n01518878\n01518878_103.JPEG 9
 73 |      H:\Data\ILSVRC2012\n01518878\n01518878_477.JPEG 9
 74 | 
 75 |  How to load features in Matlab? use the following function, see:
 76 |  prob = sc_load('prob.dat');
 77 | 
 78 |  function data = sc_load(filename, type)
 79 |      if ~exist('type', 'var') || isempty(type)
 80 |         type = 'single';
 81 |      end
 82 | 
 83 |      fid = fopen(filename, 'r');    
 84 |      rows = fread(fid, 1, type);
 85 |      cols = fread(fid, 1, type);
 86 |      data = fread(fid, rows * cols, type);    
 87 |      fclose(fid);
 88 | 
 89 |      data = reshape(data, rows, cols);
 90 |      switch type
 91 |      case 'int32'
 92 |         data = int32(data);
 93 |      case 'single'
 94 |         data = single(data);
 95 |      end
 96 |  end
 97 | 
 98 | ***/
 99 | 
100 | #include <string>
101 | #include <vector>
102 | #include "boost/algorithm/string.hpp"
103 | #include "caffe/caffe.hpp"
104 | using boost::shared_ptr;
105 | using std::string;
106 | using namespace caffe; 
107 | 
108 | #define MAX_FEAT_NUM 16
109 | 
110 | int main(int argc, char** argv)
111 | {
112 |     if (argc < 6)
113 |     {
114 |         LOG(ERROR) << "get_features proto_file model_file iterations blob_name1[,name2] save_name1[,name2]"
115 |             << "[CPU/GPU] [Device ID]";
116 |         return 1;
117 |     }
118 | 
119 |     Phase phase = TEST;
120 |     if (argc >= 7 && strcmp(argv[6], "GPU") == 0) 
121 |     {
122 |         Caffe::set_mode(Caffe::GPU);
123 |         int device_id = 0;
124 |         if (argc == 8)
125 |         {
126 |             device_id = atoi(argv[7]);
127 |         }
128 |         Caffe::SetDevice(device_id);
129 |         LOG(ERROR) << "Using GPU #" << device_id;
130 |     } else {
131 |         LOG(ERROR) << "Using CPU";
132 |         Caffe::set_mode(Caffe::CPU);
133 |     }
134 | 
135 |     boost::shared_ptr<Net<float> > feature_net;
136 |     feature_net.reset(new Net<float>(argv[1], phase));
137 |     feature_net->CopyTrainedLayersFrom(argv[2]);
138 | 
139 |     int total_iter = atoi(argv[3]);
140 |     LOG(ERROR) << "Running " << total_iter << " iterations.";
141 | 
142 |     std::string feature_blob_names(argv[4]);
143 |     std::vector<std::string> blob_names;
144 |     boost::split(blob_names, feature_blob_names, boost::is_any_of(","));
145 | 
146 |     std::string save_file_names(argv[5]);
147 |     std::vector<std::string> file_names;
148 |     boost::split(file_names, save_file_names, boost::is_any_of(","));
149 |     CHECK_EQ(blob_names.size(), file_names.size()) <<
150 |         " the number of feature blob names and save file names must be equal";
151 | 
152 |     size_t num_features = blob_names.size();
153 |     for (size_t i = 0; i < num_features; i++) 
154 |     {
155 |         CHECK(feature_net->has_blob(blob_names[i]))
156 |             << "Unknown feature blob name " << blob_names[i] << " in the network";
157 |     }
158 | 
159 |     FILE *fp[MAX_FEAT_NUM];
160 |     for (size_t i = 0; i < num_features; i++)
161 |     {
162 |         fp[i] = fopen(file_names[i].c_str(), "wb");
163 |     }
164 | 
165 |     for (int i = 0; i < total_iter; ++i)
166 |     {
167 |         feature_net->ForwardPrefilled();
168 |         for (int j = 0; j < num_features; ++j) 
169 |         {
170 |             const boost::shared_ptr<Blob<float> > feature_blob = feature_net->blob_by_name(blob_names[j]);
171 |             float num_imgs = feature_blob->num() * total_iter;
172 |             float feat_dim = feature_blob->count() / feature_blob->num();
173 |             const float* data_ptr = (const float *) feature_blob->cpu_data();
174 | 
175 |             if (i == 0)
176 |             {                
177 |                 fwrite(&feat_dim, sizeof(float), 1, fp[j]);
178 |                 fwrite(&num_imgs, sizeof(float), 1, fp[j]);        
179 |             }
180 |             fwrite(data_ptr, sizeof(float), feature_blob->count(), fp[j]);
181 |         }
182 |     }
183 | 
184 |     for (size_t i = 0; i < num_features; i++)
185 |     {
186 |         fclose(fp[i]);
187 |     }
188 |     return 0;
189 | }
190 | 


--------------------------------------------------------------------------------
/sc_load.m:
--------------------------------------------------------------------------------
 1 | function data = sc_load(filename, type)
 2 |     if ~exist('type', 'var') || isempty(type)
 3 |         type = 'single';
 4 |     end
 5 |     fid =fopen(filename, 'r');    
 6 |     rows = fread(fid, 1, type);
 7 |     cols = fread(fid, 1, type);
 8 |     data = fread(fid, rows * cols, type);    
 9 |     fclose(fid);
10 |     data = reshape(data, rows, cols);
11 |     switch type
12 |         case 'int32'
13 |             data = int32(data);
14 |         case 'single'
15 |             data = single(data);
16 |     end
17 | end
18 | 


--------------------------------------------------------------------------------
/test_caffe_manual.cpp:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <vector>
  3 | #include "caffe/caffe.hpp"
  4 | 
  5 | using namespace caffe;
  6 | 
  7 | unsigned int get_layer_index(boost::shared_ptr< Net<float> > & net, char *query_layer_name)
  8 | {
  9 |     std::string str_query(query_layer_name);    
 10 |     vector< string > const & layer_names = net->layer_names();
 11 |     for( unsigned int i = 0; i != layer_names.size(); ++i ) 
 12 |     { 
 13 |         if( str_query == layer_names[i] ) 
 14 |         { 
 15 |             return i;
 16 |         } 
 17 |     }
 18 |     LOG(FATAL) << "Unknown layer name: " << str_query;
 19 | }
 20 | 
 21 | unsigned int get_blob_index(boost::shared_ptr< Net<float> > & net, char *query_blob_name)
 22 | {
 23 |     std::string str_query(query_blob_name);    
 24 |     vector< string > const & blob_names = net->blob_names();
 25 |     for( unsigned int i = 0; i != blob_names.size(); ++i ) 
 26 |     { 
 27 |         if( str_query == blob_names[i] ) 
 28 |         { 
 29 |             return i;
 30 |         } 
 31 |     }
 32 |     LOG(FATAL) << "Unknown blob name: " << str_query;
 33 | }
 34 | 
 35 | void get_blob_features(boost::shared_ptr< Net<float> > & net, float *data_ptr, char* layer_name)
 36 | {
 37 |     unsigned int id = get_layer_index(net, layer_name);
 38 |     const vector<Blob<float>*>& output_blobs = net->top_vecs()[id];
 39 |     for (unsigned int i = 0; i < output_blobs.size(); ++i) 
 40 |     {
 41 |         switch (Caffe::mode()) {
 42 |         case Caffe::CPU:
 43 |             memcpy(data_ptr, output_blobs[i]->cpu_data(),
 44 |                 sizeof(float) * output_blobs[i]->count());
 45 |             break;
 46 |         case Caffe::GPU:
 47 |             cudaMemcpy(data_ptr, output_blobs[i]->gpu_data(),
 48 |                 sizeof(float) * output_blobs[i]->count(), cudaMemcpyDeviceToHost);
 49 |             break;
 50 |         default:
 51 |             LOG(FATAL) << "Unknown Caffe mode.";
 52 |         }
 53 |     }
 54 | }
 55 | 
 56 | #define PRINT_SHAPE1(x) \
 57 |     std::cout << (x).num() << "\t" << (x).channels() << "\t" << (x).height() << "\t" << (x).width() << "\n"; 
 58 | #define PRINT_SHAPE2(x) \
 59 |     std::cout << (x)->num() << "\t" << (x)->channels() << "\t" << (x)->height() << "\t" << (x)->width() << "\n"; 
 60 | #define PRINT_DATA(x) \
 61 |     std::cout << (x)[0] << "\t" << (x)[1] << "\n";
 62 | 
 63 | int main(int argc, char** argv) {
 64 |   
 65 |     char *proto = "H:\\Models\\Caffe\\deploy.prototxt";
 66 |     char *model = "H:\\Models\\Caffe\\bvlc_reference_caffenet.caffemodel";
 67 |     char *mean_file = "H:\\Models\\Caffe\\imagenet_mean.binaryproto";
 68 |     Phase phase = TEST;
 69 |     //Caffe::set_mode(Caffe::CPU);
 70 |     Caffe::set_mode(Caffe::GPU);
 71 |     Caffe::SetDevice(0);
 72 | 
 73 |     // processing mean
 74 |     Blob<float> image_mean;
 75 |     BlobProto blob_proto;
 76 |     const float *mean_ptr;
 77 |     bool succeed = ReadProtoFromBinaryFile(mean_file, &blob_proto);
 78 |     if (succeed) 
 79 |     {
 80 |         std::cout << "read image mean succeeded" << std::endl;
 81 |         image_mean.FromProto(blob_proto);
 82 |         mean_ptr = (const float *) image_mean.cpu_data();
 83 |         unsigned int num_pixel = image_mean.count();
 84 |         std::cout << num_pixel << "\n";
 85 |         PRINT_SHAPE1(image_mean);
 86 |         PRINT_DATA(mean_ptr);
 87 |     }
 88 |     else
 89 |     {
 90 |         LOG(FATAL) << "read image mean failed";
 91 |     }
 92 | 
 93 |     // load net model
 94 |     boost::shared_ptr<Net<float> > net(new caffe::Net<float>(proto, phase));
 95 |     net->CopyTrainedLayersFrom(model);
 96 | 
 97 |     const std::vector<boost::shared_ptr<Layer<float>  >> layers = net->layers();
 98 |     std::vector<boost::shared_ptr<Blob<float>  >> net_blobs = net->blobs();
 99 |     std::vector<string> layer_names = net->layer_names();
100 |     std::vector<string> blob_names = net->blob_names();
101 |     boost::shared_ptr<Layer<float> > layer;
102 |     boost::shared_ptr<Blob<float> > blob;
103 |     
104 |     // show input blob size
105 |     Blob<float>* input_blobs = net->input_blobs()[0];
106 |     std::cout << "\nInput blob size:\n";
107 |     PRINT_SHAPE2(input_blobs);
108 |     
109 |     // processing blobs of each layer, namely, weights and bias
110 |     const float *mem_ptr;
111 |     CHECK(layers.size() == layer_names.size());
112 |     std::cout << "\n#Layers: " << layers.size() << std::endl;
113 |     std::vector<boost::shared_ptr<Blob<float>  >> layer_blobs;
114 |     for (int i = 0; i < layers.size(); ++i)
115 |     {
116 |         layer_blobs = layers[i]->blobs();
117 |         std::cout << "\n[" << i+1 << "] layer name: " << layer_names[i] << ", type: " << layers[i]->type() << std::endl;
118 |         std::cout << "#Blobs: " << layer_blobs.size() << std::endl;
119 |         for (int j = 0; j < layer_blobs.size(); ++j)
120 |         {
121 |             blob = layer_blobs[j];
122 |             PRINT_SHAPE2(blob);
123 |             mem_ptr = (const float *) blob->cpu_data();
124 |             PRINT_DATA(mem_ptr);
125 |         }
126 |     }
127 | 
128 |     // get weights and bias from layer name
129 |     char *query_layer_name = "conv1";
130 |     const float *weight_ptr, *bias_ptr;
131 |     unsigned int layer_id = get_layer_index(net, query_layer_name);
132 |     layer = net->layers()[layer_id];
133 |     std::vector<boost::shared_ptr<Blob<float>  >> blobs = layer->blobs();
134 |     if (blobs.size() > 0)
135 |     {
136 |         std::cout << "\nweights and bias from layer: " << query_layer_name << "\n";
137 |         weight_ptr = (const float *) blobs[0]->cpu_data();
138 |         PRINT_DATA(weight_ptr);
139 |         bias_ptr = (const float *) blobs[1]->cpu_data();
140 |         PRINT_DATA(bias_ptr);
141 |     }
142 | 
143 |     // modify weights from layer name
144 |     blob = net->layers()[layer_id]->blobs()[0];
145 |     unsigned int data_size = blob->count();
146 |     float *data_ptr = new float[data_size];
147 |     caffe_copy(blob->count(), weight_ptr, data_ptr);
148 |     float *w_ptr = NULL;
149 |     data_ptr[0] = 1.1111f;
150 |     data_ptr[1] = 2.2222f;
151 |     switch (Caffe::mode())
152 |     {
153 |     case Caffe::CPU:
154 |         w_ptr = blob->mutable_cpu_data();
155 |         break;
156 |     case Caffe::GPU:
157 |         w_ptr = blob->mutable_gpu_data();
158 |         break;
159 |     default:
160 |         LOG(FATAL) << "Unknown Caffe mode";
161 |     }
162 |     caffe_copy(blob->count(), data_ptr, w_ptr);
163 |     weight_ptr = (const float *) blob->cpu_data();
164 |     delete [] data_ptr;
165 |     std::cout << "\nnew weights and bias from layer: " << query_layer_name << "\n";
166 |     PRINT_DATA(weight_ptr);
167 | 
168 |     // get features from name
169 |     char *query_blob_name = "conv1"; /* data, conv1, pool1, norm1, fc6, prob, etc */
170 |     unsigned int blob_id = get_blob_index(net, query_blob_name);
171 |     blob = net->blobs()[blob_id];
172 |     unsigned int num_data = blob->count(); /* NCHW=10x96x55x55 */
173 |     mem_ptr = (const float *) blob->cpu_data();    
174 |     std::cout << "\n#Features: " << num_data << "\n";
175 |     PRINT_DATA(mem_ptr);
176 | 
177 |     char* weights_file = "bvlc_reference_caffenet_new.caffemodel";
178 |     NetParameter net_param;
179 |     net->ToProto(&net_param, false);
180 |     WriteProtoToBinaryFile(net_param, weights_file);
181 | 
182 |     std::cout << "END" << std::endl;
183 |     return 0;
184 | }
185 | 


--------------------------------------------------------------------------------
/test_caffe_manual_output.log:
--------------------------------------------------------------------------------
  1 | read image mean succeeded
  2 | 196608
  3 | 1	3	256	256
  4 | 110.177	110.459
  5 | 
  6 | Input blob size:
  7 | 10	3	227	227
  8 | 
  9 | #Layers: 23
 10 | 
 11 | [1] layer name: conv1, type: Convolution
 12 | #Blobs: 2
 13 | 96	3	11	11
 14 | -0.00121359	0.00323653
 15 | 96	1	1	1
 16 | -0.504212	-0.188764
 17 | 
 18 | [2] layer name: relu1, type: ReLU
 19 | #Blobs: 0
 20 | 
 21 | [3] layer name: pool1, type: Pooling
 22 | #Blobs: 0
 23 | 
 24 | [4] layer name: norm1, type: LRN
 25 | #Blobs: 0
 26 | 
 27 | [5] layer name: conv2, type: Convolution
 28 | #Blobs: 2
 29 | 256	48	5	5
 30 | -0.0111258	0.0218567
 31 | 256	1	1	1
 32 | 0.982103	0.994344
 33 | 
 34 | [6] layer name: relu2, type: ReLU
 35 | #Blobs: 0
 36 | 
 37 | [7] layer name: pool2, type: Pooling
 38 | #Blobs: 0
 39 | 
 40 | [8] layer name: norm2, type: LRN
 41 | #Blobs: 0
 42 | 
 43 | [9] layer name: conv3, type: Convolution
 44 | #Blobs: 2
 45 | 384	256	3	3
 46 | -0.000527019	0.00534925
 47 | 384	1	1	1
 48 | -0.000547366	-0.00652369
 49 | 
 50 | [10] layer name: relu3, type: ReLU
 51 | #Blobs: 0
 52 | 
 53 | [11] layer name: conv4, type: Convolution
 54 | #Blobs: 2
 55 | 384	192	3	3
 56 | 0.00378311	0.000618855
 57 | 384	1	1	1
 58 | 0.884884	1.02955
 59 | 
 60 | [12] layer name: relu4, type: ReLU
 61 | #Blobs: 0
 62 | 
 63 | [13] layer name: conv5, type: Convolution
 64 | #Blobs: 2
 65 | 256	192	3	3
 66 | -0.0134502	-0.0174268
 67 | 256	1	1	1
 68 | 0.982957	1.04293
 69 | 
 70 | [14] layer name: relu5, type: ReLU
 71 | #Blobs: 0
 72 | 
 73 | [15] layer name: pool5, type: Pooling
 74 | #Blobs: 0
 75 | 
 76 | [16] layer name: fc6, type: InnerProduct
 77 | #Blobs: 2
 78 | 4096	9216	1	1
 79 | 0.00639847	0.00915686
 80 | 4096	1	1	1
 81 | 0.983698	1.00962
 82 | 
 83 | [17] layer name: relu6, type: ReLU
 84 | #Blobs: 0
 85 | 
 86 | [18] layer name: drop6, type: Dropout
 87 | #Blobs: 0
 88 | 
 89 | [19] layer name: fc7, type: InnerProduct
 90 | #Blobs: 2
 91 | 4096	4096	1	1
 92 | 0.0125212	-0.0134137
 93 | 4096	1	1	1
 94 | 1.09399	0.999266
 95 | 
 96 | [20] layer name: relu7, type: ReLU
 97 | #Blobs: 0
 98 | 
 99 | [21] layer name: drop7, type: Dropout
100 | #Blobs: 0
101 | 
102 | [22] layer name: fc8, type: InnerProduct
103 | #Blobs: 2
104 | 1000	4096	1	1
105 | 0.000160601	-0.010393
106 | 1000	1	1	1
107 | -0.196648	-0.100678
108 | 
109 | [23] layer name: prob, type: Softmax
110 | #Blobs: 0
111 | 
112 | weights and bias from layer: conv1
113 | -0.00121359	0.00323653
114 | -0.504212	-0.188764
115 | 
116 | new weights and bias from layer: conv1
117 | 1.1111	2.2222
118 | 
119 | #Features: 2904000
120 | 0	0
121 | END
122 | 


--------------------------------------------------------------------------------
/train_mnist_99.57.log:
--------------------------------------------------------------------------------
   1 | I0805 14:52:42.048267  1392 caffe.cpp:113] Use GPU with device ID 0
   2 | I0805 14:52:42.416288  1392 common.cpp:24] System entropy source not available, using fallback algorithm to generate seed instead.
   3 | I0805 14:52:42.417289  1392 caffe.cpp:121] Starting Optimization
   4 | I0805 14:52:42.417289  1392 solver.cpp:32] Initializing solver from parameters: 
   5 | test_iter: 100
   6 | test_interval: 1000
   7 | base_lr: 0.04
   8 | display: 100
   9 | max_iter: 15000
  10 | lr_policy: "inv"
  11 | gamma: 0.0002
  12 | power: 0.9
  13 | momentum: 0.8
  14 | weight_decay: 0.0001
  15 | snapshot: 5000
  16 | snapshot_prefix: "lenet"
  17 | solver_mode: GPU
  18 | net: "lenet_train_test.prototxt"
  19 | I0805 14:52:42.417289  1392 solver.cpp:70] Creating training net from net file: lenet_train_test.prototxt
  20 | I0805 14:52:42.418288  1392 net.cpp:287] The NetState phase (0) differed from the phase (1) specified by a rule in layer mnist
  21 | I0805 14:52:42.418288  1392 net.cpp:287] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy
  22 | I0805 14:52:42.418288  1392 net.cpp:42] Initializing net from parameters: 
  23 | name: "LeNet"
  24 | state {
  25 |   phase: TRAIN
  26 | }
  27 | layer {
  28 |   name: "mnist"
  29 |   type: "Data"
  30 |   top: "data"
  31 |   top: "label"
  32 |   include {
  33 |     phase: TRAIN
  34 |   }
  35 |   transform_param {
  36 |     scale: 0.00390625
  37 |   }
  38 |   data_param {
  39 |     source: "mnist-train-leveldb"
  40 |     batch_size: 64
  41 |     backend: LEVELDB
  42 |   }
  43 | }
  44 | layer {
  45 |   name: "conv1"
  46 |   type: "Convolution"
  47 |   bottom: "data"
  48 |   top: "conv1"
  49 |   param {
  50 |     lr_mult: 1
  51 |   }
  52 |   param {
  53 |     lr_mult: 2
  54 |   }
  55 |   convolution_param {
  56 |     num_output: 32
  57 |     kernel_size: 6
  58 |     stride: 1
  59 |     weight_filler {
  60 |       type: "xavier"
  61 |     }
  62 |     bias_filler {
  63 |       type: "constant"
  64 |     }
  65 |   }
  66 | }
  67 | layer {
  68 |   name: "relu1"
  69 |   type: "ReLU"
  70 |   bottom: "conv1"
  71 |   top: "conv1"
  72 | }
  73 | layer {
  74 |   name: "conv1_bn"
  75 |   type: "BN"
  76 |   bottom: "conv1"
  77 |   top: "conv1_bn"
  78 |   param {
  79 |     lr_mult: 1
  80 |     decay_mult: 0
  81 |   }
  82 |   param {
  83 |     lr_mult: 1
  84 |     decay_mult: 0
  85 |   }
  86 |   bn_param {
  87 |     scale_filler {
  88 |       type: "constant"
  89 |       value: 1
  90 |     }
  91 |     shift_filler {
  92 |       type: "constant"
  93 |       value: 0
  94 |     }
  95 |   }
  96 | }
  97 | layer {
  98 |   name: "drop1"
  99 |   type: "Dropout"
 100 |   bottom: "conv1_bn"
 101 |   top: "conv1_bn"
 102 |   dropout_param {
 103 |     dropout_ratio: 0
 104 |   }
 105 | }
 106 | layer {
 107 |   name: "pool1"
 108 |   type: "Pooling"
 109 |   bottom: "conv1_bn"
 110 |   top: "pool1"
 111 |   pooling_param {
 112 |     pool: MAX
 113 |     kernel_size: 3
 114 |     stride: 2
 115 |   }
 116 | }
 117 | layer {
 118 |   name: "conv2"
 119 |   type: "Convolution"
 120 |   bottom: "pool1"
 121 |   top: "conv2"
 122 |   param {
 123 |     lr_mult: 1
 124 |   }
 125 |   param {
 126 |     lr_mult: 2
 127 |   }
 128 |   convolution_param {
 129 |     num_output: 72
 130 |     kernel_size: 3
 131 |     stride: 1
 132 |     weight_filler {
 133 |       type: "xavier"
 134 |     }
 135 |     bias_filler {
 136 |       type: "constant"
 137 |     }
 138 |   }
 139 | }
 140 | layer {
 141 |   name: "relu2"
 142 |   type: "ReLU"
 143 |   bottom: "conv2"
 144 |   top: "conv2"
 145 | }
 146 | layer {
 147 |   name: "conv2_bn"
 148 |   type: "BN"
 149 |   bottom: "conv2"
 150 |   top: "conv2_bn"
 151 |   param {
 152 |     lr_mult: 1
 153 |     decay_mult: 0
 154 |   }
 155 |   param {
 156 |     lr_mult: 1
 157 |     decay_mult: 0
 158 |   }
 159 |   bn_param {
 160 |     scale_filler {
 161 |       type: "constant"
 162 |       value: 1
 163 |     }
 164 |     shift_filler {
 165 |       type: "constant"
 166 |       value: 0
 167 |     }
 168 |   }
 169 | }
 170 | layer {
 171 |   name: "drop2"
 172 |   type: "Dropout"
 173 |   bottom: "conv2_bn"
 174 |   top: "conv2_bn"
 175 |   dropout_param {
 176 |     dropout_ratio: 0.1
 177 |   }
 178 | }
 179 | layer {
 180 |   name: "pool2"
 181 |   type: "Pooling"
 182 |   bottom: "conv2_bn"
 183 |   top: "pool2"
 184 |   pooling_param {
 185 |     pool: MAX
 186 |     kernel_size: 2
 187 |     stride: 2
 188 |   }
 189 | }
 190 | layer {
 191 |   name: "ip1"
 192 |   type: "InnerProduct"
 193 |   bottom: "pool2"
 194 |   top: "ip1"
 195 |   param {
 196 |     lr_mult: 1
 197 |   }
 198 |   param {
 199 |     lr_mult: 2
 200 |   }
 201 |   inner_product_param {
 202 |     num_output: 320
 203 |     weight_filler {
 204 |       type: "xavier"
 205 |     }
 206 |     bias_filler {
 207 |       type: "constant"
 208 |     }
 209 |   }
 210 | }
 211 | layer {
 212 |   name: "relu3"
 213 |   type: "ReLU"
 214 |   bottom: "ip1"
 215 |   top: "ip1"
 216 | }
 217 | layer {
 218 |   name: "drop3"
 219 |   type: "Dropout"
 220 |   bottom: "ip1"
 221 |   top: "ip1"
 222 |   dropout_param {
 223 |     dropout_ratio: 0.3
 224 |   }
 225 | }
 226 | layer {
 227 |   name: "ip2"
 228 |   type: "InnerProduct"
 229 |   bottom: "ip1"
 230 |   top: "ip2"
 231 |   param {
 232 |     lr_mult: 1
 233 |   }
 234 |   param {
 235 |     lr_mult: 2
 236 |   }
 237 |   inner_product_param {
 238 |     num_output: 10
 239 |     weight_filler {
 240 |       type: "xavier"
 241 |     }
 242 |     bias_filler {
 243 |       type: "constant"
 244 |     }
 245 |   }
 246 | }
 247 | layer {
 248 |   name: "loss"
 249 |   type: "SoftmaxWithLoss"
 250 |   bottom: "ip2"
 251 |   bottom: "label"
 252 |   top: "loss"
 253 | }
 254 | I0805 14:52:42.457290  1392 layer_factory.hpp:74] Creating layer mnist
 255 | I0805 14:52:42.459291  1392 net.cpp:90] Creating Layer mnist
 256 | I0805 14:52:42.460291  1392 net.cpp:368] mnist -> data
 257 | I0805 14:52:42.460291  1392 net.cpp:368] mnist -> label
 258 | I0805 14:52:42.461292  1392 net.cpp:120] Setting up mnist
 259 | I0805 14:52:42.468291  1392 db.cpp:20] Opened leveldb mnist-train-leveldb
 260 | I0805 14:52:42.469291  1392 data_layer.cpp:52] output data size: 64,1,28,28
 261 | I0805 14:52:42.469291  1392 net.cpp:127] Top shape: 64 1 28 28 (50176)
 262 | I0805 14:52:42.470291  1392 net.cpp:127] Top shape: 64 (64)
 263 | I0805 14:52:42.470291  1392 layer_factory.hpp:74] Creating layer conv1
 264 | I0805 14:52:42.471292  1392 net.cpp:90] Creating Layer conv1
 265 | I0805 14:52:42.472291  1392 net.cpp:410] conv1 <- data
 266 | I0805 14:52:42.473291  1392 net.cpp:368] conv1 -> conv1
 267 | I0805 14:52:42.473291  1392 net.cpp:120] Setting up conv1
 268 | I0805 14:52:42.474292  1392 common.cpp:24] System entropy source not available, using fallback algorithm to generate seed instead.
 269 | I0805 14:52:42.539295  1392 net.cpp:127] Top shape: 64 32 23 23 (1083392)
 270 | I0805 14:52:42.540295  1392 layer_factory.hpp:74] Creating layer relu1
 271 | I0805 14:52:42.541296  1392 net.cpp:90] Creating Layer relu1
 272 | I0805 14:52:42.541296  1392 net.cpp:410] relu1 <- conv1
 273 | I0805 14:52:42.542295  1392 net.cpp:357] relu1 -> conv1 (in-place)
 274 | I0805 14:52:42.542295  1392 net.cpp:120] Setting up relu1
 275 | I0805 14:52:42.543295  1392 net.cpp:127] Top shape: 64 32 23 23 (1083392)
 276 | I0805 14:52:42.544296  1392 layer_factory.hpp:74] Creating layer conv1_bn
 277 | I0805 14:52:42.544296  1392 net.cpp:90] Creating Layer conv1_bn
 278 | I0805 14:52:42.544296  1392 net.cpp:410] conv1_bn <- conv1
 279 | I0805 14:52:42.545296  1392 net.cpp:368] conv1_bn -> conv1_bn
 280 | I0805 14:52:42.545296  1392 net.cpp:120] Setting up conv1_bn
 281 | I0805 14:52:42.546296  1392 net.cpp:127] Top shape: 64 32 23 23 (1083392)
 282 | I0805 14:52:42.546296  1392 layer_factory.hpp:74] Creating layer drop1
 283 | I0805 14:52:42.547297  1392 net.cpp:90] Creating Layer drop1
 284 | I0805 14:52:42.547297  1392 net.cpp:410] drop1 <- conv1_bn
 285 | I0805 14:52:42.548296  1392 net.cpp:357] drop1 -> conv1_bn (in-place)
 286 | I0805 14:52:42.548296  1392 net.cpp:120] Setting up drop1
 287 | I0805 14:52:42.549296  1392 net.cpp:127] Top shape: 64 32 23 23 (1083392)
 288 | I0805 14:52:42.550297  1392 layer_factory.hpp:74] Creating layer pool1
 289 | I0805 14:52:42.550297  1392 net.cpp:90] Creating Layer pool1
 290 | I0805 14:52:42.551296  1392 net.cpp:410] pool1 <- conv1_bn
 291 | I0805 14:52:42.551296  1392 net.cpp:368] pool1 -> pool1
 292 | I0805 14:52:42.552296  1392 net.cpp:120] Setting up pool1
 293 | I0805 14:52:42.552296  1392 net.cpp:127] Top shape: 64 32 11 11 (247808)
 294 | I0805 14:52:42.553297  1392 layer_factory.hpp:74] Creating layer conv2
 295 | I0805 14:52:42.553297  1392 net.cpp:90] Creating Layer conv2
 296 | I0805 14:52:42.554296  1392 net.cpp:410] conv2 <- pool1
 297 | I0805 14:52:42.554296  1392 net.cpp:368] conv2 -> conv2
 298 | I0805 14:52:42.554296  1392 net.cpp:120] Setting up conv2
 299 | I0805 14:52:42.555296  1392 net.cpp:127] Top shape: 64 72 9 9 (373248)
 300 | I0805 14:52:42.555296  1392 layer_factory.hpp:74] Creating layer relu2
 301 | I0805 14:52:42.556296  1392 net.cpp:90] Creating Layer relu2
 302 | I0805 14:52:42.556296  1392 net.cpp:410] relu2 <- conv2
 303 | I0805 14:52:42.556296  1392 net.cpp:357] relu2 -> conv2 (in-place)
 304 | I0805 14:52:42.556296  1392 net.cpp:120] Setting up relu2
 305 | I0805 14:52:42.557296  1392 net.cpp:127] Top shape: 64 72 9 9 (373248)
 306 | I0805 14:52:42.557296  1392 layer_factory.hpp:74] Creating layer conv2_bn
 307 | I0805 14:52:42.557296  1392 net.cpp:90] Creating Layer conv2_bn
 308 | I0805 14:52:42.558296  1392 net.cpp:410] conv2_bn <- conv2
 309 | I0805 14:52:42.558296  1392 net.cpp:368] conv2_bn -> conv2_bn
 310 | I0805 14:52:42.558296  1392 net.cpp:120] Setting up conv2_bn
 311 | I0805 14:52:42.558296  1392 net.cpp:127] Top shape: 64 72 9 9 (373248)
 312 | I0805 14:52:42.559296  1392 layer_factory.hpp:74] Creating layer drop2
 313 | I0805 14:52:42.559296  1392 net.cpp:90] Creating Layer drop2
 314 | I0805 14:52:42.559296  1392 net.cpp:410] drop2 <- conv2_bn
 315 | I0805 14:52:42.559296  1392 net.cpp:357] drop2 -> conv2_bn (in-place)
 316 | I0805 14:52:42.559296  1392 net.cpp:120] Setting up drop2
 317 | I0805 14:52:42.560297  1392 net.cpp:127] Top shape: 64 72 9 9 (373248)
 318 | I0805 14:52:42.560297  1392 layer_factory.hpp:74] Creating layer pool2
 319 | I0805 14:52:42.560297  1392 net.cpp:90] Creating Layer pool2
 320 | I0805 14:52:42.561296  1392 net.cpp:410] pool2 <- conv2_bn
 321 | I0805 14:52:42.561296  1392 net.cpp:368] pool2 -> pool2
 322 | I0805 14:52:42.561296  1392 net.cpp:120] Setting up pool2
 323 | I0805 14:52:42.562296  1392 net.cpp:127] Top shape: 64 72 5 5 (115200)
 324 | I0805 14:52:42.562296  1392 layer_factory.hpp:74] Creating layer ip1
 325 | I0805 14:52:42.562296  1392 net.cpp:90] Creating Layer ip1
 326 | I0805 14:52:42.563297  1392 net.cpp:410] ip1 <- pool2
 327 | I0805 14:52:42.563297  1392 net.cpp:368] ip1 -> ip1
 328 | I0805 14:52:42.563297  1392 net.cpp:120] Setting up ip1
 329 | I0805 14:52:42.567297  1392 net.cpp:127] Top shape: 64 320 (20480)
 330 | I0805 14:52:42.568297  1392 layer_factory.hpp:74] Creating layer relu3
 331 | I0805 14:52:42.568297  1392 net.cpp:90] Creating Layer relu3
 332 | I0805 14:52:42.569298  1392 net.cpp:410] relu3 <- ip1
 333 | I0805 14:52:42.569298  1392 net.cpp:357] relu3 -> ip1 (in-place)
 334 | I0805 14:52:42.569298  1392 net.cpp:120] Setting up relu3
 335 | I0805 14:52:42.570297  1392 net.cpp:127] Top shape: 64 320 (20480)
 336 | I0805 14:52:42.570297  1392 layer_factory.hpp:74] Creating layer drop3
 337 | I0805 14:52:42.571297  1392 net.cpp:90] Creating Layer drop3
 338 | I0805 14:52:42.571297  1392 net.cpp:410] drop3 <- ip1
 339 | I0805 14:52:42.571297  1392 net.cpp:357] drop3 -> ip1 (in-place)
 340 | I0805 14:52:42.571297  1392 net.cpp:120] Setting up drop3
 341 | I0805 14:52:42.572298  1392 net.cpp:127] Top shape: 64 320 (20480)
 342 | I0805 14:52:42.572298  1392 layer_factory.hpp:74] Creating layer ip2
 343 | I0805 14:52:42.572298  1392 net.cpp:90] Creating Layer ip2
 344 | I0805 14:52:42.572298  1392 net.cpp:410] ip2 <- ip1
 345 | I0805 14:52:42.572298  1392 net.cpp:368] ip2 -> ip2
 346 | I0805 14:52:42.573297  1392 net.cpp:120] Setting up ip2
 347 | I0805 14:52:42.573297  1392 net.cpp:127] Top shape: 64 10 (640)
 348 | I0805 14:52:42.573297  1392 layer_factory.hpp:74] Creating layer loss
 349 | I0805 14:52:42.573297  1392 net.cpp:90] Creating Layer loss
 350 | I0805 14:52:42.574297  1392 net.cpp:410] loss <- ip2
 351 | I0805 14:52:42.574297  1392 net.cpp:410] loss <- label
 352 | I0805 14:52:42.574297  1392 net.cpp:368] loss -> loss
 353 | I0805 14:52:42.574297  1392 net.cpp:120] Setting up loss
 354 | I0805 14:52:42.575297  1392 layer_factory.hpp:74] Creating layer loss
 355 | I0805 14:52:42.575297  1392 net.cpp:127] Top shape: (1)
 356 | I0805 14:52:42.575297  1392 net.cpp:129]     with loss weight 1
 357 | I0805 14:52:42.575297  1392 net.cpp:192] loss needs backward computation.
 358 | I0805 14:52:42.576297  1392 net.cpp:192] ip2 needs backward computation.
 359 | I0805 14:52:42.576297  1392 net.cpp:192] drop3 needs backward computation.
 360 | I0805 14:52:42.576297  1392 net.cpp:192] relu3 needs backward computation.
 361 | I0805 14:52:42.576297  1392 net.cpp:192] ip1 needs backward computation.
 362 | I0805 14:52:42.576297  1392 net.cpp:192] pool2 needs backward computation.
 363 | I0805 14:52:42.577297  1392 net.cpp:192] drop2 needs backward computation.
 364 | I0805 14:52:42.577297  1392 net.cpp:192] conv2_bn needs backward computation.
 365 | I0805 14:52:42.577297  1392 net.cpp:192] relu2 needs backward computation.
 366 | I0805 14:52:42.577297  1392 net.cpp:192] conv2 needs backward computation.
 367 | I0805 14:52:42.578297  1392 net.cpp:192] pool1 needs backward computation.
 368 | I0805 14:52:42.578297  1392 net.cpp:192] drop1 needs backward computation.
 369 | I0805 14:52:42.578297  1392 net.cpp:192] conv1_bn needs backward computation.
 370 | I0805 14:52:42.578297  1392 net.cpp:192] relu1 needs backward computation.
 371 | I0805 14:52:42.579298  1392 net.cpp:192] conv1 needs backward computation.
 372 | I0805 14:52:42.579298  1392 net.cpp:194] mnist does not need backward computation.
 373 | I0805 14:52:42.579298  1392 net.cpp:235] This network produces output loss
 374 | I0805 14:52:42.580298  1392 net.cpp:482] Collecting Learning Rate and Weight Decay.
 375 | I0805 14:52:42.580298  1392 net.cpp:247] Network initialization done.
 376 | I0805 14:52:42.580298  1392 net.cpp:248] Memory required for data: 25207556
 377 | I0805 14:52:42.581298  1392 solver.cpp:154] Creating test net (#0) specified by net file: lenet_train_test.prototxt
 378 | I0805 14:52:42.582298  1392 net.cpp:287] The NetState phase (1) differed from the phase (0) specified by a rule in layer mnist
 379 | I0805 14:52:42.582298  1392 net.cpp:42] Initializing net from parameters: 
 380 | name: "LeNet"
 381 | state {
 382 |   phase: TEST
 383 | }
 384 | layer {
 385 |   name: "mnist"
 386 |   type: "Data"
 387 |   top: "data"
 388 |   top: "label"
 389 |   include {
 390 |     phase: TEST
 391 |   }
 392 |   transform_param {
 393 |     scale: 0.00390625
 394 |   }
 395 |   data_param {
 396 |     source: "mnist-test-leveldb"
 397 |     batch_size: 100
 398 |     backend: LEVELDB
 399 |   }
 400 | }
 401 | layer {
 402 |   name: "conv1"
 403 |   type: "Convolution"
 404 |   bottom: "data"
 405 |   top: "conv1"
 406 |   param {
 407 |     lr_mult: 1
 408 |   }
 409 |   param {
 410 |     lr_mult: 2
 411 |   }
 412 |   convolution_param {
 413 |     num_output: 32
 414 |     kernel_size: 6
 415 |     stride: 1
 416 |     weight_filler {
 417 |       type: "xavier"
 418 |     }
 419 |     bias_filler {
 420 |       type: "constant"
 421 |     }
 422 |   }
 423 | }
 424 | layer {
 425 |   name: "relu1"
 426 |   type: "ReLU"
 427 |   bottom: "conv1"
 428 |   top: "conv1"
 429 | }
 430 | layer {
 431 |   name: "conv1_bn"
 432 |   type: "BN"
 433 |   bottom: "conv1"
 434 |   top: "conv1_bn"
 435 |   param {
 436 |     lr_mult: 1
 437 |     decay_mult: 0
 438 |   }
 439 |   param {
 440 |     lr_mult: 1
 441 |     decay_mult: 0
 442 |   }
 443 |   bn_param {
 444 |     scale_filler {
 445 |       type: "constant"
 446 |       value: 1
 447 |     }
 448 |     shift_filler {
 449 |       type: "constant"
 450 |       value: 0
 451 |     }
 452 |   }
 453 | }
 454 | layer {
 455 |   name: "drop1"
 456 |   type: "Dropout"
 457 |   bottom: "conv1_bn"
 458 |   top: "conv1_bn"
 459 |   dropout_param {
 460 |     dropout_ratio: 0
 461 |   }
 462 | }
 463 | layer {
 464 |   name: "pool1"
 465 |   type: "Pooling"
 466 |   bottom: "conv1_bn"
 467 |   top: "pool1"
 468 |   pooling_param {
 469 |     pool: MAX
 470 |     kernel_size: 3
 471 |     stride: 2
 472 |   }
 473 | }
 474 | layer {
 475 |   name: "conv2"
 476 |   type: "Convolution"
 477 |   bottom: "pool1"
 478 |   top: "conv2"
 479 |   param {
 480 |     lr_mult: 1
 481 |   }
 482 |   param {
 483 |     lr_mult: 2
 484 |   }
 485 |   convolution_param {
 486 |     num_output: 72
 487 |     kernel_size: 3
 488 |     stride: 1
 489 |     weight_filler {
 490 |       type: "xavier"
 491 |     }
 492 |     bias_filler {
 493 |       type: "constant"
 494 |     }
 495 |   }
 496 | }
 497 | layer {
 498 |   name: "relu2"
 499 |   type: "ReLU"
 500 |   bottom: "conv2"
 501 |   top: "conv2"
 502 | }
 503 | layer {
 504 |   name: "conv2_bn"
 505 |   type: "BN"
 506 |   bottom: "conv2"
 507 |   top: "conv2_bn"
 508 |   param {
 509 |     lr_mult: 1
 510 |     decay_mult: 0
 511 |   }
 512 |   param {
 513 |     lr_mult: 1
 514 |     decay_mult: 0
 515 |   }
 516 |   bn_param {
 517 |     scale_filler {
 518 |       type: "constant"
 519 |       value: 1
 520 |     }
 521 |     shift_filler {
 522 |       type: "constant"
 523 |       value: 0
 524 |     }
 525 |   }
 526 | }
 527 | layer {
 528 |   name: "drop2"
 529 |   type: "Dropout"
 530 |   bottom: "conv2_bn"
 531 |   top: "conv2_bn"
 532 |   dropout_param {
 533 |     dropout_ratio: 0.1
 534 |   }
 535 | }
 536 | layer {
 537 |   name: "pool2"
 538 |   type: "Pooling"
 539 |   bottom: "conv2_bn"
 540 |   top: "pool2"
 541 |   pooling_param {
 542 |     pool: MAX
 543 |     kernel_size: 2
 544 |     stride: 2
 545 |   }
 546 | }
 547 | layer {
 548 |   name: "ip1"
 549 |   type: "InnerProduct"
 550 |   bottom: "pool2"
 551 |   top: "ip1"
 552 |   param {
 553 |     lr_mult: 1
 554 |   }
 555 |   param {
 556 |     lr_mult: 2
 557 |   }
 558 |   inner_product_param {
 559 |     num_output: 320
 560 |     weight_filler {
 561 |       type: "xavier"
 562 |     }
 563 |     bias_filler {
 564 |       type: "constant"
 565 |     }
 566 |   }
 567 | }
 568 | layer {
 569 |   name: "relu3"
 570 |   type: "ReLU"
 571 |   bottom: "ip1"
 572 |   top: "ip1"
 573 | }
 574 | layer {
 575 |   name: "drop3"
 576 |   type: "Dropout"
 577 |   bottom: "ip1"
 578 |   top: "ip1"
 579 |   dropout_param {
 580 |     dropout_ratio: 0.3
 581 |   }
 582 | }
 583 | layer {
 584 |   name: "ip2"
 585 |   type: "InnerProduct"
 586 |   bottom: "ip1"
 587 |   top: "ip2"
 588 |   param {
 589 |     lr_mult: 1
 590 |   }
 591 |   param {
 592 |     lr_mult: 2
 593 |   }
 594 |   inner_product_param {
 595 |     num_output: 10
 596 |     weight_filler {
 597 |       type: "xavier"
 598 |     }
 599 |     bias_filler {
 600 |       type: "constant"
 601 |     }
 602 |   }
 603 | }
 604 | layer {
 605 |   name: "accuracy"
 606 |   type: "Accuracy"
 607 |   bottom: "ip2"
 608 |   bottom: "label"
 609 |   top: "accuracy"
 610 |   include {
 611 |     phase: TEST
 612 |   }
 613 | }
 614 | layer {
 615 |   name: "loss"
 616 |   type: "SoftmaxWithLoss"
 617 |   bottom: "ip2"
 618 |   bottom: "label"
 619 |   top: "loss"
 620 | }
 621 | I0805 14:52:42.609299  1392 layer_factory.hpp:74] Creating layer mnist
 622 | I0805 14:52:42.610299  1392 net.cpp:90] Creating Layer mnist
 623 | I0805 14:52:42.610299  1392 net.cpp:368] mnist -> data
 624 | I0805 14:52:42.610299  1392 net.cpp:368] mnist -> label
 625 | I0805 14:52:42.611299  1392 net.cpp:120] Setting up mnist
 626 | I0805 14:52:42.618300  1392 db.cpp:20] Opened leveldb mnist-test-leveldb
 627 | I0805 14:52:42.619300  1392 data_layer.cpp:52] output data size: 100,1,28,28
 628 | I0805 14:52:42.619300  1392 net.cpp:127] Top shape: 100 1 28 28 (78400)
 629 | I0805 14:52:42.620301  1392 net.cpp:127] Top shape: 100 (100)
 630 | I0805 14:52:42.620301  1392 layer_factory.hpp:74] Creating layer label_mnist_1_split
 631 | I0805 14:52:42.620301  1392 net.cpp:90] Creating Layer label_mnist_1_split
 632 | I0805 14:52:42.620301  1392 net.cpp:410] label_mnist_1_split <- label
 633 | I0805 14:52:42.621300  1392 net.cpp:368] label_mnist_1_split -> label_mnist_1_split_0
 634 | I0805 14:52:42.621300  1392 net.cpp:368] label_mnist_1_split -> label_mnist_1_split_1
 635 | I0805 14:52:42.621300  1392 net.cpp:120] Setting up label_mnist_1_split
 636 | I0805 14:52:42.622300  1392 net.cpp:127] Top shape: 100 (100)
 637 | I0805 14:52:42.622300  1392 net.cpp:127] Top shape: 100 (100)
 638 | I0805 14:52:42.622300  1392 layer_factory.hpp:74] Creating layer conv1
 639 | I0805 14:52:42.622300  1392 net.cpp:90] Creating Layer conv1
 640 | I0805 14:52:42.623301  1392 net.cpp:410] conv1 <- data
 641 | I0805 14:52:42.623301  1392 net.cpp:368] conv1 -> conv1
 642 | I0805 14:52:42.623301  1392 net.cpp:120] Setting up conv1
 643 | I0805 14:52:42.624300  1392 net.cpp:127] Top shape: 100 32 23 23 (1692800)
 644 | I0805 14:52:42.625300  1392 layer_factory.hpp:74] Creating layer relu1
 645 | I0805 14:52:42.625300  1392 net.cpp:90] Creating Layer relu1
 646 | I0805 14:52:42.625300  1392 net.cpp:410] relu1 <- conv1
 647 | I0805 14:52:42.625300  1392 net.cpp:357] relu1 -> conv1 (in-place)
 648 | I0805 14:52:42.626301  1392 net.cpp:120] Setting up relu1
 649 | I0805 14:52:42.626301  1392 net.cpp:127] Top shape: 100 32 23 23 (1692800)
 650 | I0805 14:52:42.626301  1392 layer_factory.hpp:74] Creating layer conv1_bn
 651 | I0805 14:52:42.626301  1392 net.cpp:90] Creating Layer conv1_bn
 652 | I0805 14:52:42.627300  1392 net.cpp:410] conv1_bn <- conv1
 653 | I0805 14:52:42.627300  1392 net.cpp:368] conv1_bn -> conv1_bn
 654 | I0805 14:52:42.627300  1392 net.cpp:120] Setting up conv1_bn
 655 | I0805 14:52:42.627300  1392 net.cpp:127] Top shape: 100 32 23 23 (1692800)
 656 | I0805 14:52:42.628300  1392 layer_factory.hpp:74] Creating layer drop1
 657 | I0805 14:52:42.628300  1392 net.cpp:90] Creating Layer drop1
 658 | I0805 14:52:42.628300  1392 net.cpp:410] drop1 <- conv1_bn
 659 | I0805 14:52:42.628300  1392 net.cpp:357] drop1 -> conv1_bn (in-place)
 660 | I0805 14:52:42.629300  1392 net.cpp:120] Setting up drop1
 661 | I0805 14:52:42.629300  1392 net.cpp:127] Top shape: 100 32 23 23 (1692800)
 662 | I0805 14:52:42.629300  1392 layer_factory.hpp:74] Creating layer pool1
 663 | I0805 14:52:42.629300  1392 net.cpp:90] Creating Layer pool1
 664 | I0805 14:52:42.630300  1392 net.cpp:410] pool1 <- conv1_bn
 665 | I0805 14:52:42.630300  1392 net.cpp:368] pool1 -> pool1
 666 | I0805 14:52:42.630300  1392 net.cpp:120] Setting up pool1
 667 | I0805 14:52:42.631300  1392 net.cpp:127] Top shape: 100 32 11 11 (387200)
 668 | I0805 14:52:42.631300  1392 layer_factory.hpp:74] Creating layer conv2
 669 | I0805 14:52:42.631300  1392 net.cpp:90] Creating Layer conv2
 670 | I0805 14:52:42.632300  1392 net.cpp:410] conv2 <- pool1
 671 | I0805 14:52:42.632300  1392 net.cpp:368] conv2 -> conv2
 672 | I0805 14:52:42.632300  1392 net.cpp:120] Setting up conv2
 673 | I0805 14:52:42.633301  1392 net.cpp:127] Top shape: 100 72 9 9 (583200)
 674 | I0805 14:52:42.633301  1392 layer_factory.hpp:74] Creating layer relu2
 675 | I0805 14:52:42.633301  1392 net.cpp:90] Creating Layer relu2
 676 | I0805 14:52:42.634301  1392 net.cpp:410] relu2 <- conv2
 677 | I0805 14:52:42.634301  1392 net.cpp:357] relu2 -> conv2 (in-place)
 678 | I0805 14:52:42.634301  1392 net.cpp:120] Setting up relu2
 679 | I0805 14:52:42.635301  1392 net.cpp:127] Top shape: 100 72 9 9 (583200)
 680 | I0805 14:52:42.635301  1392 layer_factory.hpp:74] Creating layer conv2_bn
 681 | I0805 14:52:42.635301  1392 net.cpp:90] Creating Layer conv2_bn
 682 | I0805 14:52:42.635301  1392 net.cpp:410] conv2_bn <- conv2
 683 | I0805 14:52:42.636301  1392 net.cpp:368] conv2_bn -> conv2_bn
 684 | I0805 14:52:42.636301  1392 net.cpp:120] Setting up conv2_bn
 685 | I0805 14:52:42.636301  1392 net.cpp:127] Top shape: 100 72 9 9 (583200)
 686 | I0805 14:52:42.636301  1392 layer_factory.hpp:74] Creating layer drop2
 687 | I0805 14:52:42.637301  1392 net.cpp:90] Creating Layer drop2
 688 | I0805 14:52:42.637301  1392 net.cpp:410] drop2 <- conv2_bn
 689 | I0805 14:52:42.637301  1392 net.cpp:357] drop2 -> conv2_bn (in-place)
 690 | I0805 14:52:42.637301  1392 net.cpp:120] Setting up drop2
 691 | I0805 14:52:42.638301  1392 net.cpp:127] Top shape: 100 72 9 9 (583200)
 692 | I0805 14:52:42.638301  1392 layer_factory.hpp:74] Creating layer pool2
 693 | I0805 14:52:42.638301  1392 net.cpp:90] Creating Layer pool2
 694 | I0805 14:52:42.638301  1392 net.cpp:410] pool2 <- conv2_bn
 695 | I0805 14:52:42.639302  1392 net.cpp:368] pool2 -> pool2
 696 | I0805 14:52:42.639302  1392 net.cpp:120] Setting up pool2
 697 | I0805 14:52:42.639302  1392 net.cpp:127] Top shape: 100 72 5 5 (180000)
 698 | I0805 14:52:42.639302  1392 layer_factory.hpp:74] Creating layer ip1
 699 | I0805 14:52:42.640301  1392 net.cpp:90] Creating Layer ip1
 700 | I0805 14:52:42.640301  1392 net.cpp:410] ip1 <- pool2
 701 | I0805 14:52:42.640301  1392 net.cpp:368] ip1 -> ip1
 702 | I0805 14:52:42.641301  1392 net.cpp:120] Setting up ip1
 703 | I0805 14:52:42.645301  1392 net.cpp:127] Top shape: 100 320 (32000)
 704 | I0805 14:52:42.645301  1392 layer_factory.hpp:74] Creating layer relu3
 705 | I0805 14:52:42.646301  1392 net.cpp:90] Creating Layer relu3
 706 | I0805 14:52:42.646301  1392 net.cpp:410] relu3 <- ip1
 707 | I0805 14:52:42.646301  1392 net.cpp:357] relu3 -> ip1 (in-place)
 708 | I0805 14:52:42.647301  1392 net.cpp:120] Setting up relu3
 709 | I0805 14:52:42.647301  1392 net.cpp:127] Top shape: 100 320 (32000)
 710 | I0805 14:52:42.648301  1392 layer_factory.hpp:74] Creating layer drop3
 711 | I0805 14:52:42.648301  1392 net.cpp:90] Creating Layer drop3
 712 | I0805 14:52:42.648301  1392 net.cpp:410] drop3 <- ip1
 713 | I0805 14:52:42.649302  1392 net.cpp:357] drop3 -> ip1 (in-place)
 714 | I0805 14:52:42.649302  1392 net.cpp:120] Setting up drop3
 715 | I0805 14:52:42.649302  1392 net.cpp:127] Top shape: 100 320 (32000)
 716 | I0805 14:52:42.649302  1392 layer_factory.hpp:74] Creating layer ip2
 717 | I0805 14:52:42.650302  1392 net.cpp:90] Creating Layer ip2
 718 | I0805 14:52:42.650302  1392 net.cpp:410] ip2 <- ip1
 719 | I0805 14:52:42.650302  1392 net.cpp:368] ip2 -> ip2
 720 | I0805 14:52:42.650302  1392 net.cpp:120] Setting up ip2
 721 | I0805 14:52:42.651303  1392 net.cpp:127] Top shape: 100 10 (1000)
 722 | I0805 14:52:42.651303  1392 layer_factory.hpp:74] Creating layer ip2_ip2_0_split
 723 | I0805 14:52:42.651303  1392 net.cpp:90] Creating Layer ip2_ip2_0_split
 724 | I0805 14:52:42.651303  1392 net.cpp:410] ip2_ip2_0_split <- ip2
 725 | I0805 14:52:42.652302  1392 net.cpp:368] ip2_ip2_0_split -> ip2_ip2_0_split_0
 726 | I0805 14:52:42.652302  1392 net.cpp:368] ip2_ip2_0_split -> ip2_ip2_0_split_1
 727 | I0805 14:52:42.652302  1392 net.cpp:120] Setting up ip2_ip2_0_split
 728 | I0805 14:52:42.652302  1392 net.cpp:127] Top shape: 100 10 (1000)
 729 | I0805 14:52:42.653302  1392 net.cpp:127] Top shape: 100 10 (1000)
 730 | I0805 14:52:42.653302  1392 layer_factory.hpp:74] Creating layer accuracy
 731 | I0805 14:52:42.653302  1392 net.cpp:90] Creating Layer accuracy
 732 | I0805 14:52:42.654302  1392 net.cpp:410] accuracy <- ip2_ip2_0_split_0
 733 | I0805 14:52:42.654302  1392 net.cpp:410] accuracy <- label_mnist_1_split_0
 734 | I0805 14:52:42.654302  1392 net.cpp:368] accuracy -> accuracy
 735 | I0805 14:52:42.655303  1392 net.cpp:120] Setting up accuracy
 736 | I0805 14:52:42.655303  1392 net.cpp:127] Top shape: (1)
 737 | I0805 14:52:42.655303  1392 layer_factory.hpp:74] Creating layer loss
 738 | I0805 14:52:42.655303  1392 net.cpp:90] Creating Layer loss
 739 | I0805 14:52:42.656302  1392 net.cpp:410] loss <- ip2_ip2_0_split_1
 740 | I0805 14:52:42.656302  1392 net.cpp:410] loss <- label_mnist_1_split_1
 741 | I0805 14:52:42.656302  1392 net.cpp:368] loss -> loss
 742 | I0805 14:52:42.657302  1392 net.cpp:120] Setting up loss
 743 | I0805 14:52:42.657302  1392 layer_factory.hpp:74] Creating layer loss
 744 | I0805 14:52:42.658303  1392 net.cpp:127] Top shape: (1)
 745 | I0805 14:52:42.658303  1392 net.cpp:129]     with loss weight 1
 746 | I0805 14:52:42.659302  1392 net.cpp:192] loss needs backward computation.
 747 | I0805 14:52:42.659302  1392 net.cpp:194] accuracy does not need backward computation.
 748 | I0805 14:52:42.659302  1392 net.cpp:192] ip2_ip2_0_split needs backward computation.
 749 | I0805 14:52:42.659302  1392 net.cpp:192] ip2 needs backward computation.
 750 | I0805 14:52:42.660302  1392 net.cpp:192] drop3 needs backward computation.
 751 | I0805 14:52:42.660302  1392 net.cpp:192] relu3 needs backward computation.
 752 | I0805 14:52:42.660302  1392 net.cpp:192] ip1 needs backward computation.
 753 | I0805 14:52:42.660302  1392 net.cpp:192] pool2 needs backward computation.
 754 | I0805 14:52:42.661303  1392 net.cpp:192] drop2 needs backward computation.
 755 | I0805 14:52:42.661303  1392 net.cpp:192] conv2_bn needs backward computation.
 756 | I0805 14:52:42.661303  1392 net.cpp:192] relu2 needs backward computation.
 757 | I0805 14:52:42.661303  1392 net.cpp:192] conv2 needs backward computation.
 758 | I0805 14:52:42.662302  1392 net.cpp:192] pool1 needs backward computation.
 759 | I0805 14:52:42.662302  1392 net.cpp:192] drop1 needs backward computation.
 760 | I0805 14:52:42.662302  1392 net.cpp:192] conv1_bn needs backward computation.
 761 | I0805 14:52:42.663302  1392 net.cpp:192] relu1 needs backward computation.
 762 | I0805 14:52:42.663302  1392 net.cpp:192] conv1 needs backward computation.
 763 | I0805 14:52:42.663302  1392 net.cpp:194] label_mnist_1_split does not need backward computation.
 764 | I0805 14:52:42.664302  1392 net.cpp:194] mnist does not need backward computation.
 765 | I0805 14:52:42.664302  1392 net.cpp:235] This network produces output accuracy
 766 | I0805 14:52:42.664302  1392 net.cpp:235] This network produces output loss
 767 | I0805 14:52:42.664302  1392 net.cpp:482] Collecting Learning Rate and Weight Decay.
 768 | I0805 14:52:42.665302  1392 net.cpp:247] Network initialization done.
 769 | I0805 14:52:42.665302  1392 net.cpp:248] Memory required for data: 39395608
 770 | I0805 14:52:42.665302  1392 solver.cpp:42] Solver scaffolding done.
 771 | I0805 14:52:42.665302  1392 solver.cpp:250] Solving LeNet
 772 | I0805 14:52:42.666302  1392 solver.cpp:251] Learning Rate Policy: inv
 773 | I0805 14:52:42.667302  1392 solver.cpp:294] Iteration 0, Testing net (#0)
 774 | I0805 14:52:43.083326  1392 solver.cpp:343]     Test net output #0: accuracy = 0.1007
 775 | I0805 14:52:43.083326  1392 solver.cpp:343]     Test net output #1: loss = 78.5417 (* 1 = 78.5417 loss)
 776 | I0805 14:52:43.106328  1392 solver.cpp:214] Iteration 0, loss = 2.87422
 777 | I0805 14:52:43.107328  1392 solver.cpp:229]     Train net output #0: loss = 2.87422 (* 1 = 2.87422 loss)
 778 | I0805 14:52:43.108328  1392 solver.cpp:486] Iteration 0, lr = 0.04
 779 | I0805 14:52:43.809368  1392 solver.cpp:214] Iteration 100, loss = 0.220041
 780 | I0805 14:52:43.810369  1392 solver.cpp:229]     Train net output #0: loss = 0.220041 (* 1 = 0.220041 loss)
 781 | I0805 14:52:43.810369  1392 solver.cpp:486] Iteration 100, lr = 0.0392934
 782 | I0805 14:52:44.502408  1392 solver.cpp:214] Iteration 200, loss = 0.126289
 783 | I0805 14:52:44.503408  1392 solver.cpp:229]     Train net output #0: loss = 0.126289 (* 1 = 0.126289 loss)
 784 | I0805 14:52:44.504408  1392 solver.cpp:486] Iteration 200, lr = 0.0386127
 785 | I0805 14:52:45.194447  1392 solver.cpp:214] Iteration 300, loss = 0.139079
 786 | I0805 14:52:45.195447  1392 solver.cpp:229]     Train net output #0: loss = 0.139079 (* 1 = 0.139079 loss)
 787 | I0805 14:52:45.196447  1392 solver.cpp:486] Iteration 300, lr = 0.0379564
 788 | I0805 14:52:45.889487  1392 solver.cpp:214] Iteration 400, loss = 0.0402969
 789 | I0805 14:52:45.890487  1392 solver.cpp:229]     Train net output #0: loss = 0.040297 (* 1 = 0.040297 loss)
 790 | I0805 14:52:45.891487  1392 solver.cpp:486] Iteration 400, lr = 0.0373232
 791 | I0805 14:52:46.586527  1392 solver.cpp:214] Iteration 500, loss = 0.0935015
 792 | I0805 14:52:46.586527  1392 solver.cpp:229]     Train net output #0: loss = 0.0935016 (* 1 = 0.0935016 loss)
 793 | I0805 14:52:46.587527  1392 solver.cpp:486] Iteration 500, lr = 0.0367119
 794 | I0805 14:52:47.281566  1392 solver.cpp:214] Iteration 600, loss = 0.0859815
 795 | I0805 14:52:47.281566  1392 solver.cpp:229]     Train net output #0: loss = 0.0859815 (* 1 = 0.0859815 loss)
 796 | I0805 14:52:47.282567  1392 solver.cpp:486] Iteration 600, lr = 0.0361213
 797 | I0805 14:52:47.979606  1392 solver.cpp:214] Iteration 700, loss = 0.0612219
 798 | I0805 14:52:47.979606  1392 solver.cpp:229]     Train net output #0: loss = 0.0612219 (* 1 = 0.0612219 loss)
 799 | I0805 14:52:47.980607  1392 solver.cpp:486] Iteration 700, lr = 0.0355505
 800 | I0805 14:52:48.675647  1392 solver.cpp:214] Iteration 800, loss = 0.18401
 801 | I0805 14:52:48.676646  1392 solver.cpp:229]     Train net output #0: loss = 0.18401 (* 1 = 0.18401 loss)
 802 | I0805 14:52:48.677646  1392 solver.cpp:486] Iteration 800, lr = 0.0349984
 803 | I0805 14:52:49.369686  1392 solver.cpp:214] Iteration 900, loss = 0.213497
 804 | I0805 14:52:49.369686  1392 solver.cpp:229]     Train net output #0: loss = 0.213497 (* 1 = 0.213497 loss)
 805 | I0805 14:52:49.370687  1392 solver.cpp:486] Iteration 900, lr = 0.034464
 806 | I0805 14:52:50.060725  1392 solver.cpp:294] Iteration 1000, Testing net (#0)
 807 | I0805 14:52:50.451748  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9893
 808 | I0805 14:52:50.452749  1392 solver.cpp:343]     Test net output #1: loss = 0.0339307 (* 1 = 0.0339307 loss)
 809 | I0805 14:52:50.456748  1392 solver.cpp:214] Iteration 1000, loss = 0.0163326
 810 | I0805 14:52:50.457748  1392 solver.cpp:229]     Train net output #0: loss = 0.0163326 (* 1 = 0.0163326 loss)
 811 | I0805 14:52:50.457748  1392 solver.cpp:486] Iteration 1000, lr = 0.0339466
 812 | I0805 14:52:51.157788  1392 solver.cpp:214] Iteration 1100, loss = 0.00104439
 813 | I0805 14:52:51.158788  1392 solver.cpp:229]     Train net output #0: loss = 0.00104446 (* 1 = 0.00104446 loss)
 814 | I0805 14:52:51.159788  1392 solver.cpp:486] Iteration 1100, lr = 0.0334454
 815 | I0805 14:52:51.853828  1392 solver.cpp:214] Iteration 1200, loss = 0.0300438
 816 | I0805 14:52:51.854828  1392 solver.cpp:229]     Train net output #0: loss = 0.0300439 (* 1 = 0.0300439 loss)
 817 | I0805 14:52:51.854828  1392 solver.cpp:486] Iteration 1200, lr = 0.0329595
 818 | I0805 14:52:52.543867  1392 solver.cpp:214] Iteration 1300, loss = 0.00561851
 819 | I0805 14:52:52.544867  1392 solver.cpp:229]     Train net output #0: loss = 0.00561857 (* 1 = 0.00561857 loss)
 820 | I0805 14:52:52.544867  1392 solver.cpp:486] Iteration 1300, lr = 0.0324883
 821 | I0805 14:52:53.241907  1392 solver.cpp:214] Iteration 1400, loss = 0.00394553
 822 | I0805 14:52:53.241907  1392 solver.cpp:229]     Train net output #0: loss = 0.00394557 (* 1 = 0.00394557 loss)
 823 | I0805 14:52:53.242908  1392 solver.cpp:486] Iteration 1400, lr = 0.032031
 824 | I0805 14:52:53.938947  1392 solver.cpp:214] Iteration 1500, loss = 0.0390139
 825 | I0805 14:52:53.939947  1392 solver.cpp:229]     Train net output #0: loss = 0.039014 (* 1 = 0.039014 loss)
 826 | I0805 14:52:53.939947  1392 solver.cpp:486] Iteration 1500, lr = 0.0315872
 827 | I0805 14:52:54.632987  1392 solver.cpp:214] Iteration 1600, loss = 0.045935
 828 | I0805 14:52:54.633987  1392 solver.cpp:229]     Train net output #0: loss = 0.0459351 (* 1 = 0.0459351 loss)
 829 | I0805 14:52:54.633987  1392 solver.cpp:486] Iteration 1600, lr = 0.0311561
 830 | I0805 14:52:55.326027  1392 solver.cpp:214] Iteration 1700, loss = 0.0930766
 831 | I0805 14:52:55.326027  1392 solver.cpp:229]     Train net output #0: loss = 0.0930766 (* 1 = 0.0930766 loss)
 832 | I0805 14:52:55.327028  1392 solver.cpp:486] Iteration 1700, lr = 0.0307373
 833 | I0805 14:52:56.022066  1392 solver.cpp:214] Iteration 1800, loss = 0.00682616
 834 | I0805 14:52:56.022066  1392 solver.cpp:229]     Train net output #0: loss = 0.00682622 (* 1 = 0.00682622 loss)
 835 | I0805 14:52:56.023066  1392 solver.cpp:486] Iteration 1800, lr = 0.0303302
 836 | I0805 14:52:56.719106  1392 solver.cpp:214] Iteration 1900, loss = 0.122121
 837 | I0805 14:52:56.719106  1392 solver.cpp:229]     Train net output #0: loss = 0.122121 (* 1 = 0.122121 loss)
 838 | I0805 14:52:56.720106  1392 solver.cpp:486] Iteration 1900, lr = 0.0299343
 839 | I0805 14:52:57.405145  1392 solver.cpp:294] Iteration 2000, Testing net (#0)
 840 | I0805 14:52:57.808168  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9898
 841 | I0805 14:52:57.809170  1392 solver.cpp:343]     Test net output #1: loss = 0.0301438 (* 1 = 0.0301438 loss)
 842 | I0805 14:52:57.813169  1392 solver.cpp:214] Iteration 2000, loss = 0.0324452
 843 | I0805 14:52:57.814169  1392 solver.cpp:229]     Train net output #0: loss = 0.0324453 (* 1 = 0.0324453 loss)
 844 | I0805 14:52:57.814169  1392 solver.cpp:486] Iteration 2000, lr = 0.0295491
 845 | I0805 14:52:58.507208  1392 solver.cpp:214] Iteration 2100, loss = 0.0160458
 846 | I0805 14:52:58.507208  1392 solver.cpp:229]     Train net output #0: loss = 0.016046 (* 1 = 0.016046 loss)
 847 | I0805 14:52:58.508209  1392 solver.cpp:486] Iteration 2100, lr = 0.0291743
 848 | I0805 14:52:59.200248  1392 solver.cpp:214] Iteration 2200, loss = 0.00501125
 849 | I0805 14:52:59.201248  1392 solver.cpp:229]     Train net output #0: loss = 0.00501135 (* 1 = 0.00501135 loss)
 850 | I0805 14:52:59.201248  1392 solver.cpp:486] Iteration 2200, lr = 0.0288094
 851 | I0805 14:52:59.896288  1392 solver.cpp:214] Iteration 2300, loss = 0.0237116
 852 | I0805 14:52:59.896288  1392 solver.cpp:229]     Train net output #0: loss = 0.0237118 (* 1 = 0.0237118 loss)
 853 | I0805 14:52:59.897289  1392 solver.cpp:486] Iteration 2300, lr = 0.0284539
 854 | I0805 14:53:00.594328  1392 solver.cpp:214] Iteration 2400, loss = 0.0360984
 855 | I0805 14:53:00.595329  1392 solver.cpp:229]     Train net output #0: loss = 0.0360985 (* 1 = 0.0360985 loss)
 856 | I0805 14:53:00.596328  1392 solver.cpp:486] Iteration 2400, lr = 0.0281076
 857 | I0805 14:53:01.289368  1392 solver.cpp:214] Iteration 2500, loss = 0.0620604
 858 | I0805 14:53:01.289368  1392 solver.cpp:229]     Train net output #0: loss = 0.0620605 (* 1 = 0.0620605 loss)
 859 | I0805 14:53:01.290369  1392 solver.cpp:486] Iteration 2500, lr = 0.0277701
 860 | I0805 14:53:01.985407  1392 solver.cpp:214] Iteration 2600, loss = 0.036869
 861 | I0805 14:53:01.985407  1392 solver.cpp:229]     Train net output #0: loss = 0.0368692 (* 1 = 0.0368692 loss)
 862 | I0805 14:53:01.986407  1392 solver.cpp:486] Iteration 2600, lr = 0.0274411
 863 | I0805 14:53:02.676447  1392 solver.cpp:214] Iteration 2700, loss = 0.106417
 864 | I0805 14:53:02.676447  1392 solver.cpp:229]     Train net output #0: loss = 0.106417 (* 1 = 0.106417 loss)
 865 | I0805 14:53:02.677448  1392 solver.cpp:486] Iteration 2700, lr = 0.0271201
 866 | I0805 14:53:03.368487  1392 solver.cpp:214] Iteration 2800, loss = 0.000549857
 867 | I0805 14:53:03.369488  1392 solver.cpp:229]     Train net output #0: loss = 0.000549995 (* 1 = 0.000549995 loss)
 868 | I0805 14:53:03.369488  1392 solver.cpp:486] Iteration 2800, lr = 0.026807
 869 | I0805 14:53:04.065526  1392 solver.cpp:214] Iteration 2900, loss = 0.0262977
 870 | I0805 14:53:04.065526  1392 solver.cpp:229]     Train net output #0: loss = 0.0262979 (* 1 = 0.0262979 loss)
 871 | I0805 14:53:04.066526  1392 solver.cpp:486] Iteration 2900, lr = 0.0265014
 872 | I0805 14:53:04.755566  1392 solver.cpp:294] Iteration 3000, Testing net (#0)
 873 | I0805 14:53:05.154589  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9933
 874 | I0805 14:53:05.155589  1392 solver.cpp:343]     Test net output #1: loss = 0.020941 (* 1 = 0.020941 loss)
 875 | I0805 14:53:05.159590  1392 solver.cpp:214] Iteration 3000, loss = 0.00563839
 876 | I0805 14:53:05.160589  1392 solver.cpp:229]     Train net output #0: loss = 0.00563854 (* 1 = 0.00563854 loss)
 877 | I0805 14:53:05.160589  1392 solver.cpp:486] Iteration 3000, lr = 0.0262031
 878 | I0805 14:53:05.861629  1392 solver.cpp:214] Iteration 3100, loss = 0.00378355
 879 | I0805 14:53:05.862629  1392 solver.cpp:229]     Train net output #0: loss = 0.0037837 (* 1 = 0.0037837 loss)
 880 | I0805 14:53:05.863629  1392 solver.cpp:486] Iteration 3100, lr = 0.0259117
 881 | I0805 14:53:06.556669  1392 solver.cpp:214] Iteration 3200, loss = 0.00495449
 882 | I0805 14:53:06.557669  1392 solver.cpp:229]     Train net output #0: loss = 0.00495464 (* 1 = 0.00495464 loss)
 883 | I0805 14:53:06.557669  1392 solver.cpp:486] Iteration 3200, lr = 0.0256272
 884 | I0805 14:53:07.251709  1392 solver.cpp:214] Iteration 3300, loss = 0.0154928
 885 | I0805 14:53:07.251709  1392 solver.cpp:229]     Train net output #0: loss = 0.0154929 (* 1 = 0.0154929 loss)
 886 | I0805 14:53:07.252709  1392 solver.cpp:486] Iteration 3300, lr = 0.0253491
 887 | I0805 14:53:07.943748  1392 solver.cpp:214] Iteration 3400, loss = 0.0010491
 888 | I0805 14:53:07.944748  1392 solver.cpp:229]     Train net output #0: loss = 0.00104925 (* 1 = 0.00104925 loss)
 889 | I0805 14:53:07.945749  1392 solver.cpp:486] Iteration 3400, lr = 0.0250774
 890 | I0805 14:53:08.641788  1392 solver.cpp:214] Iteration 3500, loss = 0.00815444
 891 | I0805 14:53:08.642788  1392 solver.cpp:229]     Train net output #0: loss = 0.00815459 (* 1 = 0.00815459 loss)
 892 | I0805 14:53:08.642788  1392 solver.cpp:486] Iteration 3500, lr = 0.0248117
 893 | I0805 14:53:09.335829  1392 solver.cpp:214] Iteration 3600, loss = 0.00881401
 894 | I0805 14:53:09.335829  1392 solver.cpp:229]     Train net output #0: loss = 0.00881419 (* 1 = 0.00881419 loss)
 895 | I0805 14:53:09.336828  1392 solver.cpp:486] Iteration 3600, lr = 0.0245519
 896 | I0805 14:53:10.028867  1392 solver.cpp:214] Iteration 3700, loss = 0.0718557
 897 | I0805 14:53:10.028867  1392 solver.cpp:229]     Train net output #0: loss = 0.0718559 (* 1 = 0.0718559 loss)
 898 | I0805 14:53:10.029868  1392 solver.cpp:486] Iteration 3700, lr = 0.0242977
 899 | I0805 14:53:10.723907  1392 solver.cpp:214] Iteration 3800, loss = 0.0243846
 900 | I0805 14:53:10.723907  1392 solver.cpp:229]     Train net output #0: loss = 0.0243848 (* 1 = 0.0243848 loss)
 901 | I0805 14:53:10.724907  1392 solver.cpp:486] Iteration 3800, lr = 0.0240491
 902 | I0805 14:53:11.417948  1392 solver.cpp:214] Iteration 3900, loss = 0.010712
 903 | I0805 14:53:11.418947  1392 solver.cpp:229]     Train net output #0: loss = 0.0107122 (* 1 = 0.0107122 loss)
 904 | I0805 14:53:11.418947  1392 solver.cpp:486] Iteration 3900, lr = 0.0238058
 905 | I0805 14:53:12.104986  1392 solver.cpp:294] Iteration 4000, Testing net (#0)
 906 | I0805 14:53:12.506009  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9941
 907 | I0805 14:53:12.507009  1392 solver.cpp:343]     Test net output #1: loss = 0.0183649 (* 1 = 0.0183649 loss)
 908 | I0805 14:53:12.512011  1392 solver.cpp:214] Iteration 4000, loss = 0.0114788
 909 | I0805 14:53:12.513010  1392 solver.cpp:229]     Train net output #0: loss = 0.0114789 (* 1 = 0.0114789 loss)
 910 | I0805 14:53:12.513010  1392 solver.cpp:486] Iteration 4000, lr = 0.0235676
 911 | I0805 14:53:13.210049  1392 solver.cpp:214] Iteration 4100, loss = 0.000130875
 912 | I0805 14:53:13.211050  1392 solver.cpp:229]     Train net output #0: loss = 0.000131057 (* 1 = 0.000131057 loss)
 913 | I0805 14:53:13.212050  1392 solver.cpp:486] Iteration 4100, lr = 0.0233344
 914 | I0805 14:53:13.904089  1392 solver.cpp:214] Iteration 4200, loss = 0.00127553
 915 | I0805 14:53:13.905089  1392 solver.cpp:229]     Train net output #0: loss = 0.00127569 (* 1 = 0.00127569 loss)
 916 | I0805 14:53:13.905089  1392 solver.cpp:486] Iteration 4200, lr = 0.023106
 917 | I0805 14:53:14.598129  1392 solver.cpp:214] Iteration 4300, loss = 0.00505828
 918 | I0805 14:53:14.598129  1392 solver.cpp:229]     Train net output #0: loss = 0.00505844 (* 1 = 0.00505844 loss)
 919 | I0805 14:53:14.599129  1392 solver.cpp:486] Iteration 4300, lr = 0.0228822
 920 | I0805 14:53:15.295169  1392 solver.cpp:214] Iteration 4400, loss = 0.000817688
 921 | I0805 14:53:15.295169  1392 solver.cpp:229]     Train net output #0: loss = 0.000817851 (* 1 = 0.000817851 loss)
 922 | I0805 14:53:15.296169  1392 solver.cpp:486] Iteration 4400, lr = 0.022663
 923 | I0805 14:53:15.997210  1392 solver.cpp:214] Iteration 4500, loss = 0.00614459
 924 | I0805 14:53:15.998209  1392 solver.cpp:229]     Train net output #0: loss = 0.00614476 (* 1 = 0.00614476 loss)
 925 | I0805 14:53:15.998209  1392 solver.cpp:486] Iteration 4500, lr = 0.0224482
 926 | I0805 14:53:16.708250  1392 solver.cpp:214] Iteration 4600, loss = 0.0246302
 927 | I0805 14:53:16.709250  1392 solver.cpp:229]     Train net output #0: loss = 0.0246304 (* 1 = 0.0246304 loss)
 928 | I0805 14:53:16.710250  1392 solver.cpp:486] Iteration 4600, lr = 0.0222377
 929 | I0805 14:53:17.421290  1392 solver.cpp:214] Iteration 4700, loss = 0.0138153
 930 | I0805 14:53:17.421290  1392 solver.cpp:229]     Train net output #0: loss = 0.0138154 (* 1 = 0.0138154 loss)
 931 | I0805 14:53:17.422291  1392 solver.cpp:486] Iteration 4700, lr = 0.0220312
 932 | I0805 14:53:18.138331  1392 solver.cpp:214] Iteration 4800, loss = 0.00829904
 933 | I0805 14:53:18.138331  1392 solver.cpp:229]     Train net output #0: loss = 0.00829922 (* 1 = 0.00829922 loss)
 934 | I0805 14:53:18.139331  1392 solver.cpp:486] Iteration 4800, lr = 0.0218288
 935 | I0805 14:53:18.856372  1392 solver.cpp:214] Iteration 4900, loss = 0.000418008
 936 | I0805 14:53:18.856372  1392 solver.cpp:229]     Train net output #0: loss = 0.000418191 (* 1 = 0.000418191 loss)
 937 | I0805 14:53:18.857372  1392 solver.cpp:486] Iteration 4900, lr = 0.0216302
 938 | I0805 14:53:19.573413  1392 solver.cpp:361] Snapshotting to lenet_iter_5000.caffemodel
 939 | I0805 14:53:19.585414  1392 solver.cpp:369] Snapshotting solver state to lenet_iter_5000.solverstate
 940 | I0805 14:53:19.593415  1392 solver.cpp:294] Iteration 5000, Testing net (#0)
 941 | I0805 14:53:20.009438  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9937
 942 | I0805 14:53:20.010438  1392 solver.cpp:343]     Test net output #1: loss = 0.0210218 (* 1 = 0.0210218 loss)
 943 | I0805 14:53:20.014439  1392 solver.cpp:214] Iteration 5000, loss = 0.0439826
 944 | I0805 14:53:20.015439  1392 solver.cpp:229]     Train net output #0: loss = 0.0439828 (* 1 = 0.0439828 loss)
 945 | I0805 14:53:20.016439  1392 solver.cpp:486] Iteration 5000, lr = 0.0214355
 946 | I0805 14:53:20.739480  1392 solver.cpp:214] Iteration 5100, loss = 0.0212865
 947 | I0805 14:53:20.739480  1392 solver.cpp:229]     Train net output #0: loss = 0.0212867 (* 1 = 0.0212867 loss)
 948 | I0805 14:53:20.740480  1392 solver.cpp:486] Iteration 5100, lr = 0.0212444
 949 | I0805 14:53:21.462522  1392 solver.cpp:214] Iteration 5200, loss = 0.00098768
 950 | I0805 14:53:21.463521  1392 solver.cpp:229]     Train net output #0: loss = 0.000987855 (* 1 = 0.000987855 loss)
 951 | I0805 14:53:21.464522  1392 solver.cpp:486] Iteration 5200, lr = 0.0210568
 952 | I0805 14:53:22.186563  1392 solver.cpp:214] Iteration 5300, loss = 0.000718615
 953 | I0805 14:53:22.187563  1392 solver.cpp:229]     Train net output #0: loss = 0.000718786 (* 1 = 0.000718786 loss)
 954 | I0805 14:53:22.187563  1392 solver.cpp:486] Iteration 5300, lr = 0.0208727
 955 | I0805 14:53:22.906605  1392 solver.cpp:214] Iteration 5400, loss = 0.00133868
 956 | I0805 14:53:22.907604  1392 solver.cpp:229]     Train net output #0: loss = 0.00133886 (* 1 = 0.00133886 loss)
 957 | I0805 14:53:22.908604  1392 solver.cpp:486] Iteration 5400, lr = 0.020692
 958 | I0805 14:53:23.627645  1392 solver.cpp:214] Iteration 5500, loss = 0.000897586
 959 | I0805 14:53:23.628645  1392 solver.cpp:229]     Train net output #0: loss = 0.000897764 (* 1 = 0.000897764 loss)
 960 | I0805 14:53:23.629645  1392 solver.cpp:486] Iteration 5500, lr = 0.0205146
 961 | I0805 14:53:24.359688  1392 solver.cpp:214] Iteration 5600, loss = 9.13558e-005
 962 | I0805 14:53:24.360687  1392 solver.cpp:229]     Train net output #0: loss = 9.15377e-005 (* 1 = 9.15377e-005 loss)
 963 | I0805 14:53:24.360687  1392 solver.cpp:486] Iteration 5600, lr = 0.0203403
 964 | I0805 14:53:25.095729  1392 solver.cpp:214] Iteration 5700, loss = 0.0016139
 965 | I0805 14:53:25.096729  1392 solver.cpp:229]     Train net output #0: loss = 0.00161407 (* 1 = 0.00161407 loss)
 966 | I0805 14:53:25.097729  1392 solver.cpp:486] Iteration 5700, lr = 0.0201692
 967 | I0805 14:53:25.830771  1392 solver.cpp:214] Iteration 5800, loss = 0.00897269
 968 | I0805 14:53:25.830771  1392 solver.cpp:229]     Train net output #0: loss = 0.00897286 (* 1 = 0.00897286 loss)
 969 | I0805 14:53:25.831771  1392 solver.cpp:486] Iteration 5800, lr = 0.020001
 970 | I0805 14:53:26.567813  1392 solver.cpp:214] Iteration 5900, loss = 0.00267578
 971 | I0805 14:53:26.567813  1392 solver.cpp:229]     Train net output #0: loss = 0.00267595 (* 1 = 0.00267595 loss)
 972 | I0805 14:53:26.568814  1392 solver.cpp:486] Iteration 5900, lr = 0.0198358
 973 | I0805 14:53:27.298856  1392 solver.cpp:294] Iteration 6000, Testing net (#0)
 974 | I0805 14:53:27.719879  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9944
 975 | I0805 14:53:27.720880  1392 solver.cpp:343]     Test net output #1: loss = 0.0177348 (* 1 = 0.0177348 loss)
 976 | I0805 14:53:27.725880  1392 solver.cpp:214] Iteration 6000, loss = 0.00269533
 977 | I0805 14:53:27.725880  1392 solver.cpp:229]     Train net output #0: loss = 0.0026955 (* 1 = 0.0026955 loss)
 978 | I0805 14:53:27.726881  1392 solver.cpp:486] Iteration 6000, lr = 0.0196734
 979 | I0805 14:53:28.466922  1392 solver.cpp:214] Iteration 6100, loss = 0.001992
 980 | I0805 14:53:28.467922  1392 solver.cpp:229]     Train net output #0: loss = 0.00199218 (* 1 = 0.00199218 loss)
 981 | I0805 14:53:28.468922  1392 solver.cpp:486] Iteration 6100, lr = 0.0195138
 982 | I0805 14:53:29.202965  1392 solver.cpp:214] Iteration 6200, loss = 0.0042955
 983 | I0805 14:53:29.203964  1392 solver.cpp:229]     Train net output #0: loss = 0.00429569 (* 1 = 0.00429569 loss)
 984 | I0805 14:53:29.204964  1392 solver.cpp:486] Iteration 6200, lr = 0.0193569
 985 | I0805 14:53:29.944007  1392 solver.cpp:214] Iteration 6300, loss = 0.00114569
 986 | I0805 14:53:29.944007  1392 solver.cpp:229]     Train net output #0: loss = 0.0011459 (* 1 = 0.0011459 loss)
 987 | I0805 14:53:29.945008  1392 solver.cpp:486] Iteration 6300, lr = 0.0192027
 988 | I0805 14:53:30.684049  1392 solver.cpp:214] Iteration 6400, loss = 0.000806044
 989 | I0805 14:53:30.685050  1392 solver.cpp:229]     Train net output #0: loss = 0.000806251 (* 1 = 0.000806251 loss)
 990 | I0805 14:53:30.685050  1392 solver.cpp:486] Iteration 6400, lr = 0.019051
 991 | I0805 14:53:31.425091  1392 solver.cpp:214] Iteration 6500, loss = 0.00453469
 992 | I0805 14:53:31.425091  1392 solver.cpp:229]     Train net output #0: loss = 0.00453489 (* 1 = 0.00453489 loss)
 993 | I0805 14:53:31.426091  1392 solver.cpp:486] Iteration 6500, lr = 0.0189019
 994 | I0805 14:53:32.166134  1392 solver.cpp:214] Iteration 6600, loss = 0.0772493
 995 | I0805 14:53:32.167135  1392 solver.cpp:229]     Train net output #0: loss = 0.0772495 (* 1 = 0.0772495 loss)
 996 | I0805 14:53:32.168134  1392 solver.cpp:486] Iteration 6600, lr = 0.0187552
 997 | I0805 14:53:32.902176  1392 solver.cpp:214] Iteration 6700, loss = 0.0040816
 998 | I0805 14:53:32.903177  1392 solver.cpp:229]     Train net output #0: loss = 0.0040818 (* 1 = 0.0040818 loss)
 999 | I0805 14:53:32.903177  1392 solver.cpp:486] Iteration 6700, lr = 0.0186108
1000 | I0805 14:53:33.641218  1392 solver.cpp:214] Iteration 6800, loss = 0.00129661
1001 | I0805 14:53:33.641218  1392 solver.cpp:229]     Train net output #0: loss = 0.00129682 (* 1 = 0.00129682 loss)
1002 | I0805 14:53:33.642218  1392 solver.cpp:486] Iteration 6800, lr = 0.0184688
1003 | I0805 14:53:34.377260  1392 solver.cpp:214] Iteration 6900, loss = 5.42768e-005
1004 | I0805 14:53:34.377260  1392 solver.cpp:229]     Train net output #0: loss = 5.44799e-005 (* 1 = 5.44799e-005 loss)
1005 | I0805 14:53:34.378260  1392 solver.cpp:486] Iteration 6900, lr = 0.0183291
1006 | I0805 14:53:35.110302  1392 solver.cpp:294] Iteration 7000, Testing net (#0)
1007 | I0805 14:53:35.531327  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9946
1008 | I0805 14:53:35.532326  1392 solver.cpp:343]     Test net output #1: loss = 0.0195909 (* 1 = 0.0195909 loss)
1009 | I0805 14:53:35.536326  1392 solver.cpp:214] Iteration 7000, loss = 0.0020149
1010 | I0805 14:53:35.537327  1392 solver.cpp:229]     Train net output #0: loss = 0.00201511 (* 1 = 0.00201511 loss)
1011 | I0805 14:53:35.537327  1392 solver.cpp:486] Iteration 7000, lr = 0.0181916
1012 | I0805 14:53:36.275369  1392 solver.cpp:214] Iteration 7100, loss = 0.0015403
1013 | I0805 14:53:36.275369  1392 solver.cpp:229]     Train net output #0: loss = 0.00154052 (* 1 = 0.00154052 loss)
1014 | I0805 14:53:36.276370  1392 solver.cpp:486] Iteration 7100, lr = 0.0180562
1015 | I0805 14:53:37.013411  1392 solver.cpp:214] Iteration 7200, loss = 0.00327097
1016 | I0805 14:53:37.013411  1392 solver.cpp:229]     Train net output #0: loss = 0.0032712 (* 1 = 0.0032712 loss)
1017 | I0805 14:53:37.014411  1392 solver.cpp:486] Iteration 7200, lr = 0.0179229
1018 | I0805 14:53:37.753453  1392 solver.cpp:214] Iteration 7300, loss = 0.012502
1019 | I0805 14:53:37.753453  1392 solver.cpp:229]     Train net output #0: loss = 0.0125022 (* 1 = 0.0125022 loss)
1020 | I0805 14:53:37.754453  1392 solver.cpp:486] Iteration 7300, lr = 0.0177917
1021 | I0805 14:53:38.495496  1392 solver.cpp:214] Iteration 7400, loss = 0.0244695
1022 | I0805 14:53:38.496496  1392 solver.cpp:229]     Train net output #0: loss = 0.0244698 (* 1 = 0.0244698 loss)
1023 | I0805 14:53:38.496496  1392 solver.cpp:486] Iteration 7400, lr = 0.0176626
1024 | I0805 14:53:39.236538  1392 solver.cpp:214] Iteration 7500, loss = 0.00111646
1025 | I0805 14:53:39.237539  1392 solver.cpp:229]     Train net output #0: loss = 0.00111668 (* 1 = 0.00111668 loss)
1026 | I0805 14:53:39.237539  1392 solver.cpp:486] Iteration 7500, lr = 0.0175353
1027 | I0805 14:53:39.978580  1392 solver.cpp:214] Iteration 7600, loss = 0.0110739
1028 | I0805 14:53:39.979581  1392 solver.cpp:229]     Train net output #0: loss = 0.0110741 (* 1 = 0.0110741 loss)
1029 | I0805 14:53:39.980581  1392 solver.cpp:486] Iteration 7600, lr = 0.01741
1030 | I0805 14:53:40.719624  1392 solver.cpp:214] Iteration 7700, loss = 0.00653506
1031 | I0805 14:53:40.719624  1392 solver.cpp:229]     Train net output #0: loss = 0.0065353 (* 1 = 0.0065353 loss)
1032 | I0805 14:53:40.720623  1392 solver.cpp:486] Iteration 7700, lr = 0.0172866
1033 | I0805 14:53:41.454665  1392 solver.cpp:214] Iteration 7800, loss = 0.000371143
1034 | I0805 14:53:41.455665  1392 solver.cpp:229]     Train net output #0: loss = 0.00037139 (* 1 = 0.00037139 loss)
1035 | I0805 14:53:41.455665  1392 solver.cpp:486] Iteration 7800, lr = 0.017165
1036 | I0805 14:53:42.191707  1392 solver.cpp:214] Iteration 7900, loss = 9.31453e-005
1037 | I0805 14:53:42.192708  1392 solver.cpp:229]     Train net output #0: loss = 9.33931e-005 (* 1 = 9.33931e-005 loss)
1038 | I0805 14:53:42.192708  1392 solver.cpp:486] Iteration 7900, lr = 0.0170452
1039 | I0805 14:53:42.921749  1392 solver.cpp:294] Iteration 8000, Testing net (#0)
1040 | I0805 14:53:43.344774  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9947
1041 | I0805 14:53:43.344774  1392 solver.cpp:343]     Test net output #1: loss = 0.0167619 (* 1 = 0.0167619 loss)
1042 | I0805 14:53:43.349773  1392 solver.cpp:214] Iteration 8000, loss = 0.000271104
1043 | I0805 14:53:43.350774  1392 solver.cpp:229]     Train net output #0: loss = 0.000271356 (* 1 = 0.000271356 loss)
1044 | I0805 14:53:43.350774  1392 solver.cpp:486] Iteration 8000, lr = 0.0169272
1045 | I0805 14:53:44.091816  1392 solver.cpp:214] Iteration 8100, loss = 0.00243713
1046 | I0805 14:53:44.092816  1392 solver.cpp:229]     Train net output #0: loss = 0.00243739 (* 1 = 0.00243739 loss)
1047 | I0805 14:53:44.092816  1392 solver.cpp:486] Iteration 8100, lr = 0.0168108
1048 | I0805 14:53:44.826858  1392 solver.cpp:214] Iteration 8200, loss = 0.000995319
1049 | I0805 14:53:44.827858  1392 solver.cpp:229]     Train net output #0: loss = 0.000995574 (* 1 = 0.000995574 loss)
1050 | I0805 14:53:44.828858  1392 solver.cpp:486] Iteration 8200, lr = 0.0166962
1051 | I0805 14:53:45.566900  1392 solver.cpp:214] Iteration 8300, loss = 0.0157538
1052 | I0805 14:53:45.566900  1392 solver.cpp:229]     Train net output #0: loss = 0.0157541 (* 1 = 0.0157541 loss)
1053 | I0805 14:53:45.567900  1392 solver.cpp:486] Iteration 8300, lr = 0.0165831
1054 | I0805 14:53:46.307943  1392 solver.cpp:214] Iteration 8400, loss = 0.00639222
1055 | I0805 14:53:46.308943  1392 solver.cpp:229]     Train net output #0: loss = 0.00639247 (* 1 = 0.00639247 loss)
1056 | I0805 14:53:46.308943  1392 solver.cpp:486] Iteration 8400, lr = 0.0164717
1057 | I0805 14:53:47.050986  1392 solver.cpp:214] Iteration 8500, loss = 0.00120033
1058 | I0805 14:53:47.050986  1392 solver.cpp:229]     Train net output #0: loss = 0.00120057 (* 1 = 0.00120057 loss)
1059 | I0805 14:53:47.051985  1392 solver.cpp:486] Iteration 8500, lr = 0.0163619
1060 | I0805 14:53:47.792027  1392 solver.cpp:214] Iteration 8600, loss = 2.0404e-005
1061 | I0805 14:53:47.792027  1392 solver.cpp:229]     Train net output #0: loss = 2.0649e-005 (* 1 = 2.0649e-005 loss)
1062 | I0805 14:53:47.793027  1392 solver.cpp:486] Iteration 8600, lr = 0.0162535
1063 | I0805 14:53:48.528070  1392 solver.cpp:214] Iteration 8700, loss = 0.00443287
1064 | I0805 14:53:48.529070  1392 solver.cpp:229]     Train net output #0: loss = 0.00443312 (* 1 = 0.00443312 loss)
1065 | I0805 14:53:48.529070  1392 solver.cpp:486] Iteration 8700, lr = 0.0161467
1066 | I0805 14:53:49.268112  1392 solver.cpp:214] Iteration 8800, loss = 0.00139713
1067 | I0805 14:53:49.269112  1392 solver.cpp:229]     Train net output #0: loss = 0.00139737 (* 1 = 0.00139737 loss)
1068 | I0805 14:53:49.269112  1392 solver.cpp:486] Iteration 8800, lr = 0.0160414
1069 | I0805 14:53:50.011154  1392 solver.cpp:214] Iteration 8900, loss = 0.000137165
1070 | I0805 14:53:50.011154  1392 solver.cpp:229]     Train net output #0: loss = 0.000137404 (* 1 = 0.000137404 loss)
1071 | I0805 14:53:50.012154  1392 solver.cpp:486] Iteration 8900, lr = 0.0159375
1072 | I0805 14:53:50.751198  1392 solver.cpp:294] Iteration 9000, Testing net (#0)
1073 | I0805 14:53:51.170222  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9938
1074 | I0805 14:53:51.170222  1392 solver.cpp:343]     Test net output #1: loss = 0.0212181 (* 1 = 0.0212181 loss)
1075 | I0805 14:53:51.175221  1392 solver.cpp:214] Iteration 9000, loss = 0.00263929
1076 | I0805 14:53:51.176221  1392 solver.cpp:229]     Train net output #0: loss = 0.00263953 (* 1 = 0.00263953 loss)
1077 | I0805 14:53:51.176221  1392 solver.cpp:486] Iteration 9000, lr = 0.015835
1078 | I0805 14:53:51.916263  1392 solver.cpp:214] Iteration 9100, loss = 0.00258828
1079 | I0805 14:53:51.917263  1392 solver.cpp:229]     Train net output #0: loss = 0.00258852 (* 1 = 0.00258852 loss)
1080 | I0805 14:53:51.917263  1392 solver.cpp:486] Iteration 9100, lr = 0.0157339
1081 | I0805 14:53:52.659307  1392 solver.cpp:214] Iteration 9200, loss = 0.000192979
1082 | I0805 14:53:52.660306  1392 solver.cpp:229]     Train net output #0: loss = 0.000193216 (* 1 = 0.000193216 loss)
1083 | I0805 14:53:52.661306  1392 solver.cpp:486] Iteration 9200, lr = 0.0156341
1084 | I0805 14:53:53.401348  1392 solver.cpp:214] Iteration 9300, loss = 0.000233888
1085 | I0805 14:53:53.401348  1392 solver.cpp:229]     Train net output #0: loss = 0.000234127 (* 1 = 0.000234127 loss)
1086 | I0805 14:53:53.402348  1392 solver.cpp:486] Iteration 9300, lr = 0.0155357
1087 | I0805 14:53:54.144392  1392 solver.cpp:214] Iteration 9400, loss = 0.0032883
1088 | I0805 14:53:54.144392  1392 solver.cpp:229]     Train net output #0: loss = 0.00328854 (* 1 = 0.00328854 loss)
1089 | I0805 14:53:54.145391  1392 solver.cpp:486] Iteration 9400, lr = 0.0154386
1090 | I0805 14:53:54.887434  1392 solver.cpp:214] Iteration 9500, loss = 0.000106236
1091 | I0805 14:53:54.888433  1392 solver.cpp:229]     Train net output #0: loss = 0.000106476 (* 1 = 0.000106476 loss)
1092 | I0805 14:53:54.888433  1392 solver.cpp:486] Iteration 9500, lr = 0.0153427
1093 | I0805 14:53:55.636476  1392 solver.cpp:214] Iteration 9600, loss = 0.00724748
1094 | I0805 14:53:55.636476  1392 solver.cpp:229]     Train net output #0: loss = 0.00724772 (* 1 = 0.00724772 loss)
1095 | I0805 14:53:55.636476  1392 solver.cpp:486] Iteration 9600, lr = 0.0152481
1096 | I0805 14:53:56.386519  1392 solver.cpp:214] Iteration 9700, loss = 0.000535149
1097 | I0805 14:53:56.387519  1392 solver.cpp:229]     Train net output #0: loss = 0.000535388 (* 1 = 0.000535388 loss)
1098 | I0805 14:53:56.387519  1392 solver.cpp:486] Iteration 9700, lr = 0.0151547
1099 | I0805 14:53:57.132562  1392 solver.cpp:214] Iteration 9800, loss = 0.0027088
1100 | I0805 14:53:57.133563  1392 solver.cpp:229]     Train net output #0: loss = 0.00270903 (* 1 = 0.00270903 loss)
1101 | I0805 14:53:57.133563  1392 solver.cpp:486] Iteration 9800, lr = 0.0150625
1102 | I0805 14:53:57.878604  1392 solver.cpp:214] Iteration 9900, loss = 0.00340623
1103 | I0805 14:53:57.879604  1392 solver.cpp:229]     Train net output #0: loss = 0.00340646 (* 1 = 0.00340646 loss)
1104 | I0805 14:53:57.880604  1392 solver.cpp:486] Iteration 9900, lr = 0.0149715
1105 | I0805 14:53:58.620647  1392 solver.cpp:361] Snapshotting to lenet_iter_10000.caffemodel
1106 | I0805 14:53:58.632647  1392 solver.cpp:369] Snapshotting solver state to lenet_iter_10000.solverstate
1107 | I0805 14:53:58.639648  1392 solver.cpp:294] Iteration 10000, Testing net (#0)
1108 | I0805 14:53:59.065672  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9956
1109 | I0805 14:53:59.065672  1392 solver.cpp:343]     Test net output #1: loss = 0.0163376 (* 1 = 0.0163376 loss)
1110 | I0805 14:53:59.071673  1392 solver.cpp:214] Iteration 10000, loss = 0.000284814
1111 | I0805 14:53:59.071673  1392 solver.cpp:229]     Train net output #0: loss = 0.000285046 (* 1 = 0.000285046 loss)
1112 | I0805 14:53:59.072674  1392 solver.cpp:486] Iteration 10000, lr = 0.0148816
1113 | I0805 14:53:59.815716  1392 solver.cpp:214] Iteration 10100, loss = 0.000493709
1114 | I0805 14:53:59.815716  1392 solver.cpp:229]     Train net output #0: loss = 0.000493938 (* 1 = 0.000493938 loss)
1115 | I0805 14:53:59.816715  1392 solver.cpp:486] Iteration 10100, lr = 0.0147929
1116 | I0805 14:54:00.566758  1392 solver.cpp:214] Iteration 10200, loss = 0.0172551
1117 | I0805 14:54:00.567759  1392 solver.cpp:229]     Train net output #0: loss = 0.0172553 (* 1 = 0.0172553 loss)
1118 | I0805 14:54:00.567759  1392 solver.cpp:486] Iteration 10200, lr = 0.0147053
1119 | I0805 14:54:01.309801  1392 solver.cpp:214] Iteration 10300, loss = 0.000248785
1120 | I0805 14:54:01.310801  1392 solver.cpp:229]     Train net output #0: loss = 0.000249006 (* 1 = 0.000249006 loss)
1121 | I0805 14:54:01.311801  1392 solver.cpp:486] Iteration 10300, lr = 0.0146188
1122 | I0805 14:54:02.053843  1392 solver.cpp:214] Iteration 10400, loss = 0.00275543
1123 | I0805 14:54:02.053843  1392 solver.cpp:229]     Train net output #0: loss = 0.00275565 (* 1 = 0.00275565 loss)
1124 | I0805 14:54:02.054843  1392 solver.cpp:486] Iteration 10400, lr = 0.0145333
1125 | I0805 14:54:02.801887  1392 solver.cpp:214] Iteration 10500, loss = 0.00512701
1126 | I0805 14:54:02.801887  1392 solver.cpp:229]     Train net output #0: loss = 0.00512723 (* 1 = 0.00512723 loss)
1127 | I0805 14:54:02.802886  1392 solver.cpp:486] Iteration 10500, lr = 0.0144489
1128 | I0805 14:54:03.544929  1392 solver.cpp:214] Iteration 10600, loss = 0.000242352
1129 | I0805 14:54:03.544929  1392 solver.cpp:229]     Train net output #0: loss = 0.000242577 (* 1 = 0.000242577 loss)
1130 | I0805 14:54:03.545928  1392 solver.cpp:486] Iteration 10600, lr = 0.0143655
1131 | I0805 14:54:04.286972  1392 solver.cpp:214] Iteration 10700, loss = 0.000278695
1132 | I0805 14:54:04.286972  1392 solver.cpp:229]     Train net output #0: loss = 0.000278918 (* 1 = 0.000278918 loss)
1133 | I0805 14:54:04.287971  1392 solver.cpp:486] Iteration 10700, lr = 0.0142831
1134 | I0805 14:54:05.031013  1392 solver.cpp:214] Iteration 10800, loss = 0.00107858
1135 | I0805 14:54:05.031013  1392 solver.cpp:229]     Train net output #0: loss = 0.0010788 (* 1 = 0.0010788 loss)
1136 | I0805 14:54:05.032013  1392 solver.cpp:486] Iteration 10800, lr = 0.0142017
1137 | I0805 14:54:05.779057  1392 solver.cpp:214] Iteration 10900, loss = 0.00286186
1138 | I0805 14:54:05.780056  1392 solver.cpp:229]     Train net output #0: loss = 0.00286208 (* 1 = 0.00286208 loss)
1139 | I0805 14:54:05.780056  1392 solver.cpp:486] Iteration 10900, lr = 0.0141213
1140 | I0805 14:54:06.518098  1392 solver.cpp:294] Iteration 11000, Testing net (#0)
1141 | I0805 14:54:06.941123  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9952
1142 | I0805 14:54:06.942123  1392 solver.cpp:343]     Test net output #1: loss = 0.0174111 (* 1 = 0.0174111 loss)
1143 | I0805 14:54:06.947124  1392 solver.cpp:214] Iteration 11000, loss = 0.000760555
1144 | I0805 14:54:06.947124  1392 solver.cpp:229]     Train net output #0: loss = 0.00076078 (* 1 = 0.00076078 loss)
1145 | I0805 14:54:06.948123  1392 solver.cpp:486] Iteration 11000, lr = 0.0140419
1146 | I0805 14:54:07.689165  1392 solver.cpp:214] Iteration 11100, loss = 0.000516106
1147 | I0805 14:54:07.690166  1392 solver.cpp:229]     Train net output #0: loss = 0.000516333 (* 1 = 0.000516333 loss)
1148 | I0805 14:54:07.691166  1392 solver.cpp:486] Iteration 11100, lr = 0.0139634
1149 | I0805 14:54:08.439208  1392 solver.cpp:214] Iteration 11200, loss = 0.000770474
1150 | I0805 14:54:08.440208  1392 solver.cpp:229]     Train net output #0: loss = 0.000770702 (* 1 = 0.000770702 loss)
1151 | I0805 14:54:08.441208  1392 solver.cpp:486] Iteration 11200, lr = 0.0138858
1152 | I0805 14:54:09.181252  1392 solver.cpp:214] Iteration 11300, loss = 0.000217331
1153 | I0805 14:54:09.181252  1392 solver.cpp:229]     Train net output #0: loss = 0.00021756 (* 1 = 0.00021756 loss)
1154 | I0805 14:54:09.182251  1392 solver.cpp:486] Iteration 11300, lr = 0.0138091
1155 | I0805 14:54:09.928294  1392 solver.cpp:214] Iteration 11400, loss = 0.000424193
1156 | I0805 14:54:09.929294  1392 solver.cpp:229]     Train net output #0: loss = 0.00042442 (* 1 = 0.00042442 loss)
1157 | I0805 14:54:09.929294  1392 solver.cpp:486] Iteration 11400, lr = 0.0137333
1158 | I0805 14:54:10.670336  1392 solver.cpp:214] Iteration 11500, loss = 0.000439667
1159 | I0805 14:54:10.671336  1392 solver.cpp:229]     Train net output #0: loss = 0.000439895 (* 1 = 0.000439895 loss)
1160 | I0805 14:54:10.672336  1392 solver.cpp:486] Iteration 11500, lr = 0.0136583
1161 | I0805 14:54:11.412379  1392 solver.cpp:214] Iteration 11600, loss = 0.000728036
1162 | I0805 14:54:11.413378  1392 solver.cpp:229]     Train net output #0: loss = 0.000728263 (* 1 = 0.000728263 loss)
1163 | I0805 14:54:11.413378  1392 solver.cpp:486] Iteration 11600, lr = 0.0135843
1164 | I0805 14:54:12.152421  1392 solver.cpp:214] Iteration 11700, loss = 4.24944e-005
1165 | I0805 14:54:12.153421  1392 solver.cpp:229]     Train net output #0: loss = 4.27263e-005 (* 1 = 4.27263e-005 loss)
1166 | I0805 14:54:12.154422  1392 solver.cpp:486] Iteration 11700, lr = 0.013511
1167 | I0805 14:54:12.898463  1392 solver.cpp:214] Iteration 11800, loss = 0.00542866
1168 | I0805 14:54:12.898463  1392 solver.cpp:229]     Train net output #0: loss = 0.00542889 (* 1 = 0.00542889 loss)
1169 | I0805 14:54:12.899463  1392 solver.cpp:486] Iteration 11800, lr = 0.0134386
1170 | I0805 14:54:13.642506  1392 solver.cpp:214] Iteration 11900, loss = 0.00137749
1171 | I0805 14:54:13.642506  1392 solver.cpp:229]     Train net output #0: loss = 0.00137772 (* 1 = 0.00137772 loss)
1172 | I0805 14:54:13.643507  1392 solver.cpp:486] Iteration 11900, lr = 0.013367
1173 | I0805 14:54:14.381548  1392 solver.cpp:294] Iteration 12000, Testing net (#0)
1174 | I0805 14:54:14.806573  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9957
1175 | I0805 14:54:14.806573  1392 solver.cpp:343]     Test net output #1: loss = 0.0177655 (* 1 = 0.0177655 loss)
1176 | I0805 14:54:14.811573  1392 solver.cpp:214] Iteration 12000, loss = 0.0131612
1177 | I0805 14:54:14.812573  1392 solver.cpp:229]     Train net output #0: loss = 0.0131614 (* 1 = 0.0131614 loss)
1178 | I0805 14:54:14.812573  1392 solver.cpp:486] Iteration 12000, lr = 0.0132962
1179 | I0805 14:54:15.556615  1392 solver.cpp:214] Iteration 12100, loss = 0.00379404
1180 | I0805 14:54:15.557616  1392 solver.cpp:229]     Train net output #0: loss = 0.00379428 (* 1 = 0.00379428 loss)
1181 | I0805 14:54:15.557616  1392 solver.cpp:486] Iteration 12100, lr = 0.0132262
1182 | I0805 14:54:16.296658  1392 solver.cpp:214] Iteration 12200, loss = 0.000480589
1183 | I0805 14:54:16.297658  1392 solver.cpp:229]     Train net output #0: loss = 0.000480827 (* 1 = 0.000480827 loss)
1184 | I0805 14:54:16.298658  1392 solver.cpp:486] Iteration 12200, lr = 0.013157
1185 | I0805 14:54:17.042701  1392 solver.cpp:214] Iteration 12300, loss = 0.000535732
1186 | I0805 14:54:17.043701  1392 solver.cpp:229]     Train net output #0: loss = 0.000535974 (* 1 = 0.000535974 loss)
1187 | I0805 14:54:17.043701  1392 solver.cpp:486] Iteration 12300, lr = 0.0130885
1188 | I0805 14:54:17.783743  1392 solver.cpp:214] Iteration 12400, loss = 0.00221962
1189 | I0805 14:54:17.783743  1392 solver.cpp:229]     Train net output #0: loss = 0.00221987 (* 1 = 0.00221987 loss)
1190 | I0805 14:54:17.784744  1392 solver.cpp:486] Iteration 12400, lr = 0.0130208
1191 | I0805 14:54:18.521785  1392 solver.cpp:214] Iteration 12500, loss = 0.021138
1192 | I0805 14:54:18.522785  1392 solver.cpp:229]     Train net output #0: loss = 0.0211383 (* 1 = 0.0211383 loss)
1193 | I0805 14:54:18.523785  1392 solver.cpp:486] Iteration 12500, lr = 0.0129538
1194 | I0805 14:54:19.269829  1392 solver.cpp:214] Iteration 12600, loss = 0.0292871
1195 | I0805 14:54:19.270828  1392 solver.cpp:229]     Train net output #0: loss = 0.0292874 (* 1 = 0.0292874 loss)
1196 | I0805 14:54:19.270828  1392 solver.cpp:486] Iteration 12600, lr = 0.0128876
1197 | I0805 14:54:20.010870  1392 solver.cpp:214] Iteration 12700, loss = 0.00116427
1198 | I0805 14:54:20.011870  1392 solver.cpp:229]     Train net output #0: loss = 0.00116451 (* 1 = 0.00116451 loss)
1199 | I0805 14:54:20.011870  1392 solver.cpp:486] Iteration 12700, lr = 0.012822
1200 | I0805 14:54:20.755913  1392 solver.cpp:214] Iteration 12800, loss = 7.37607e-005
1201 | I0805 14:54:20.756913  1392 solver.cpp:229]     Train net output #0: loss = 7.39952e-005 (* 1 = 7.39952e-005 loss)
1202 | I0805 14:54:20.756913  1392 solver.cpp:486] Iteration 12800, lr = 0.0127572
1203 | I0805 14:54:21.492955  1392 solver.cpp:214] Iteration 12900, loss = 0.00010704
1204 | I0805 14:54:21.492955  1392 solver.cpp:229]     Train net output #0: loss = 0.000107275 (* 1 = 0.000107275 loss)
1205 | I0805 14:54:21.493955  1392 solver.cpp:486] Iteration 12900, lr = 0.012693
1206 | I0805 14:54:22.227998  1392 solver.cpp:294] Iteration 13000, Testing net (#0)
1207 | I0805 14:54:22.647022  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9951
1208 | I0805 14:54:22.648021  1392 solver.cpp:343]     Test net output #1: loss = 0.0184569 (* 1 = 0.0184569 loss)
1209 | I0805 14:54:22.652021  1392 solver.cpp:214] Iteration 13000, loss = 0.000132562
1210 | I0805 14:54:22.653022  1392 solver.cpp:229]     Train net output #0: loss = 0.000132799 (* 1 = 0.000132799 loss)
1211 | I0805 14:54:22.654021  1392 solver.cpp:486] Iteration 13000, lr = 0.0126295
1212 | I0805 14:54:23.392065  1392 solver.cpp:214] Iteration 13100, loss = 9.7784e-005
1213 | I0805 14:54:23.392065  1392 solver.cpp:229]     Train net output #0: loss = 9.80218e-005 (* 1 = 9.80218e-005 loss)
1214 | I0805 14:54:23.393064  1392 solver.cpp:486] Iteration 13100, lr = 0.0125667
1215 | I0805 14:54:24.134106  1392 solver.cpp:214] Iteration 13200, loss = 0.000102151
1216 | I0805 14:54:24.134106  1392 solver.cpp:229]     Train net output #0: loss = 0.00010239 (* 1 = 0.00010239 loss)
1217 | I0805 14:54:24.135107  1392 solver.cpp:486] Iteration 13200, lr = 0.0125046
1218 | I0805 14:54:24.875149  1392 solver.cpp:214] Iteration 13300, loss = 0.013581
1219 | I0805 14:54:24.876148  1392 solver.cpp:229]     Train net output #0: loss = 0.0135812 (* 1 = 0.0135812 loss)
1220 | I0805 14:54:24.877149  1392 solver.cpp:486] Iteration 13300, lr = 0.0124431
1221 | I0805 14:54:25.620192  1392 solver.cpp:214] Iteration 13400, loss = 0.000315848
1222 | I0805 14:54:25.621191  1392 solver.cpp:229]     Train net output #0: loss = 0.000316088 (* 1 = 0.000316088 loss)
1223 | I0805 14:54:25.621191  1392 solver.cpp:486] Iteration 13400, lr = 0.0123822
1224 | I0805 14:54:26.360234  1392 solver.cpp:214] Iteration 13500, loss = 0.00148853
1225 | I0805 14:54:26.361233  1392 solver.cpp:229]     Train net output #0: loss = 0.00148877 (* 1 = 0.00148877 loss)
1226 | I0805 14:54:26.362233  1392 solver.cpp:486] Iteration 13500, lr = 0.0123219
1227 | I0805 14:54:27.104276  1392 solver.cpp:214] Iteration 13600, loss = 9.85666e-005
1228 | I0805 14:54:27.104276  1392 solver.cpp:229]     Train net output #0: loss = 9.88035e-005 (* 1 = 9.88035e-005 loss)
1229 | I0805 14:54:27.105276  1392 solver.cpp:486] Iteration 13600, lr = 0.0122623
1230 | I0805 14:54:27.846318  1392 solver.cpp:214] Iteration 13700, loss = 0.000936646
1231 | I0805 14:54:27.846318  1392 solver.cpp:229]     Train net output #0: loss = 0.000936882 (* 1 = 0.000936882 loss)
1232 | I0805 14:54:27.847318  1392 solver.cpp:486] Iteration 13700, lr = 0.0122033
1233 | I0805 14:54:28.589361  1392 solver.cpp:214] Iteration 13800, loss = 0.00012109
1234 | I0805 14:54:28.589361  1392 solver.cpp:229]     Train net output #0: loss = 0.000121322 (* 1 = 0.000121322 loss)
1235 | I0805 14:54:28.590361  1392 solver.cpp:486] Iteration 13800, lr = 0.0121448
1236 | I0805 14:54:29.332403  1392 solver.cpp:214] Iteration 13900, loss = 0.000808294
1237 | I0805 14:54:29.333403  1392 solver.cpp:229]     Train net output #0: loss = 0.000808529 (* 1 = 0.000808529 loss)
1238 | I0805 14:54:29.333403  1392 solver.cpp:486] Iteration 13900, lr = 0.012087
1239 | I0805 14:54:30.072446  1392 solver.cpp:294] Iteration 14000, Testing net (#0)
1240 | I0805 14:54:30.489470  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9953
1241 | I0805 14:54:30.489470  1392 solver.cpp:343]     Test net output #1: loss = 0.0178747 (* 1 = 0.0178747 loss)
1242 | I0805 14:54:30.494470  1392 solver.cpp:214] Iteration 14000, loss = 0.000820519
1243 | I0805 14:54:30.495471  1392 solver.cpp:229]     Train net output #0: loss = 0.000820755 (* 1 = 0.000820755 loss)
1244 | I0805 14:54:30.495471  1392 solver.cpp:486] Iteration 14000, lr = 0.0120297
1245 | I0805 14:54:31.236512  1392 solver.cpp:214] Iteration 14100, loss = 0.00430224
1246 | I0805 14:54:31.237512  1392 solver.cpp:229]     Train net output #0: loss = 0.00430247 (* 1 = 0.00430247 loss)
1247 | I0805 14:54:31.237512  1392 solver.cpp:486] Iteration 14100, lr = 0.011973
1248 | I0805 14:54:31.976555  1392 solver.cpp:214] Iteration 14200, loss = 0.000967773
1249 | I0805 14:54:31.977555  1392 solver.cpp:229]     Train net output #0: loss = 0.000968004 (* 1 = 0.000968004 loss)
1250 | I0805 14:54:31.977555  1392 solver.cpp:486] Iteration 14200, lr = 0.0119169
1251 | I0805 14:54:32.724597  1392 solver.cpp:214] Iteration 14300, loss = 0.000148073
1252 | I0805 14:54:32.724597  1392 solver.cpp:229]     Train net output #0: loss = 0.000148301 (* 1 = 0.000148301 loss)
1253 | I0805 14:54:32.725597  1392 solver.cpp:486] Iteration 14300, lr = 0.0118613
1254 | I0805 14:54:33.472640  1392 solver.cpp:214] Iteration 14400, loss = 0.000768556
1255 | I0805 14:54:33.472640  1392 solver.cpp:229]     Train net output #0: loss = 0.000768787 (* 1 = 0.000768787 loss)
1256 | I0805 14:54:33.473640  1392 solver.cpp:486] Iteration 14400, lr = 0.0118062
1257 | I0805 14:54:34.214684  1392 solver.cpp:214] Iteration 14500, loss = 0.000170701
1258 | I0805 14:54:34.214684  1392 solver.cpp:229]     Train net output #0: loss = 0.000170932 (* 1 = 0.000170932 loss)
1259 | I0805 14:54:34.215683  1392 solver.cpp:486] Iteration 14500, lr = 0.0117517
1260 | I0805 14:54:34.961725  1392 solver.cpp:214] Iteration 14600, loss = 0.0017472
1261 | I0805 14:54:34.962725  1392 solver.cpp:229]     Train net output #0: loss = 0.00174743 (* 1 = 0.00174743 loss)
1262 | I0805 14:54:34.962725  1392 solver.cpp:486] Iteration 14600, lr = 0.0116978
1263 | I0805 14:54:35.704768  1392 solver.cpp:214] Iteration 14700, loss = 3.93064e-005
1264 | I0805 14:54:35.704768  1392 solver.cpp:229]     Train net output #0: loss = 3.95355e-005 (* 1 = 3.95355e-005 loss)
1265 | I0805 14:54:35.705768  1392 solver.cpp:486] Iteration 14700, lr = 0.0116443
1266 | I0805 14:54:36.451812  1392 solver.cpp:214] Iteration 14800, loss = 0.0013484
1267 | I0805 14:54:36.452811  1392 solver.cpp:229]     Train net output #0: loss = 0.00134863 (* 1 = 0.00134863 loss)
1268 | I0805 14:54:36.453811  1392 solver.cpp:486] Iteration 14800, lr = 0.0115914
1269 | I0805 14:54:37.200853  1392 solver.cpp:214] Iteration 14900, loss = 0.00275396
1270 | I0805 14:54:37.201853  1392 solver.cpp:229]     Train net output #0: loss = 0.00275419 (* 1 = 0.00275419 loss)
1271 | I0805 14:54:37.201853  1392 solver.cpp:486] Iteration 14900, lr = 0.0115389
1272 | I0805 14:54:37.945896  1392 solver.cpp:361] Snapshotting to lenet_iter_15000.caffemodel
1273 | I0805 14:54:37.957897  1392 solver.cpp:369] Snapshotting solver state to lenet_iter_15000.solverstate
1274 | I0805 14:54:37.968897  1392 solver.cpp:276] Iteration 15000, loss = 8.69586e-005
1275 | I0805 14:54:37.969897  1392 solver.cpp:294] Iteration 15000, Testing net (#0)
1276 | I0805 14:54:38.396922  1392 solver.cpp:343]     Test net output #0: accuracy = 0.9952
1277 | I0805 14:54:38.396922  1392 solver.cpp:343]     Test net output #1: loss = 0.0172062 (* 1 = 0.0172062 loss)
1278 | I0805 14:54:38.397922  1392 solver.cpp:281] Optimization Done.
1279 | I0805 14:54:38.397922  1392 caffe.cpp:134] Optimization Done.
1280 | 


--------------------------------------------------------------------------------
/train_mnist_99.58.log:
--------------------------------------------------------------------------------
   1 | I0806 09:45:15.961009 11748 caffe.cpp:113] Use GPU with device ID 0
   2 | I0806 09:45:16.327029 11748 common.cpp:24] System entropy source not available, using fallback algorithm to generate seed instead.
   3 | I0806 09:45:16.327029 11748 caffe.cpp:121] Starting Optimization
   4 | I0806 09:45:16.327029 11748 solver.cpp:32] Initializing solver from parameters: 
   5 | test_iter: 100
   6 | test_interval: 1000
   7 | base_lr: 0.04
   8 | display: 100
   9 | max_iter: 15000
  10 | lr_policy: "step"
  11 | gamma: 0.1428571
  12 | momentum: 0.8
  13 | weight_decay: 0.0001
  14 | stepsize: 6000
  15 | snapshot: 5000
  16 | snapshot_prefix: "lenet"
  17 | solver_mode: GPU
  18 | net: "lenet_train_test.prototxt"
  19 | I0806 09:45:16.328030 11748 solver.cpp:70] Creating training net from net file: lenet_train_test.prototxt
  20 | I0806 09:45:16.328030 11748 net.cpp:287] The NetState phase (0) differed from the phase (1) specified by a rule in layer mnist
  21 | I0806 09:45:16.328030 11748 net.cpp:287] The NetState phase (0) differed from the phase (1) specified by a rule in layer accuracy
  22 | I0806 09:45:16.328030 11748 net.cpp:42] Initializing net from parameters: 
  23 | name: "LeNet"
  24 | state {
  25 |   phase: TRAIN
  26 | }
  27 | layer {
  28 |   name: "mnist"
  29 |   type: "Data"
  30 |   top: "data"
  31 |   top: "label"
  32 |   include {
  33 |     phase: TRAIN
  34 |   }
  35 |   transform_param {
  36 |     scale: 0.00390625
  37 |   }
  38 |   data_param {
  39 |     source: "mnist-train-leveldb"
  40 |     batch_size: 64
  41 |     backend: LEVELDB
  42 |   }
  43 | }
  44 | layer {
  45 |   name: "conv1"
  46 |   type: "Convolution"
  47 |   bottom: "data"
  48 |   top: "conv1"
  49 |   param {
  50 |     lr_mult: 1
  51 |   }
  52 |   param {
  53 |     lr_mult: 2
  54 |   }
  55 |   convolution_param {
  56 |     num_output: 30
  57 |     kernel_size: 7
  58 |     stride: 1
  59 |     weight_filler {
  60 |       type: "xavier"
  61 |     }
  62 |     bias_filler {
  63 |       type: "constant"
  64 |     }
  65 |   }
  66 | }
  67 | layer {
  68 |   name: "relu1"
  69 |   type: "ReLU"
  70 |   bottom: "conv1"
  71 |   top: "conv1"
  72 | }
  73 | layer {
  74 |   name: "conv1_bn"
  75 |   type: "BN"
  76 |   bottom: "conv1"
  77 |   top: "conv1_bn"
  78 |   param {
  79 |     lr_mult: 1
  80 |     decay_mult: 0
  81 |   }
  82 |   param {
  83 |     lr_mult: 1
  84 |     decay_mult: 0
  85 |   }
  86 |   bn_param {
  87 |     scale_filler {
  88 |       type: "constant"
  89 |       value: 1
  90 |     }
  91 |     shift_filler {
  92 |       type: "constant"
  93 |       value: 0
  94 |     }
  95 |   }
  96 | }
  97 | layer {
  98 |   name: "pool1"
  99 |   type: "Pooling"
 100 |   bottom: "conv1_bn"
 101 |   top: "pool1"
 102 |   pooling_param {
 103 |     pool: MAX
 104 |     kernel_size: 2
 105 |     stride: 2
 106 |   }
 107 | }
 108 | layer {
 109 |   name: "conv2"
 110 |   type: "Convolution"
 111 |   bottom: "pool1"
 112 |   top: "conv2"
 113 |   param {
 114 |     lr_mult: 1
 115 |   }
 116 |   param {
 117 |     lr_mult: 2
 118 |   }
 119 |   convolution_param {
 120 |     num_output: 70
 121 |     kernel_size: 3
 122 |     stride: 1
 123 |     weight_filler {
 124 |       type: "xavier"
 125 |     }
 126 |     bias_filler {
 127 |       type: "constant"
 128 |     }
 129 |   }
 130 | }
 131 | layer {
 132 |   name: "relu2"
 133 |   type: "ReLU"
 134 |   bottom: "conv2"
 135 |   top: "conv2"
 136 | }
 137 | layer {
 138 |   name: "conv2_bn"
 139 |   type: "BN"
 140 |   bottom: "conv2"
 141 |   top: "conv2_bn"
 142 |   param {
 143 |     lr_mult: 1
 144 |     decay_mult: 0
 145 |   }
 146 |   param {
 147 |     lr_mult: 1
 148 |     decay_mult: 0
 149 |   }
 150 |   bn_param {
 151 |     scale_filler {
 152 |       type: "constant"
 153 |       value: 1
 154 |     }
 155 |     shift_filler {
 156 |       type: "constant"
 157 |       value: 0
 158 |     }
 159 |   }
 160 | }
 161 | layer {
 162 |   name: "drop1"
 163 |   type: "Dropout"
 164 |   bottom: "conv2_bn"
 165 |   top: "conv2_bn"
 166 |   dropout_param {
 167 |     dropout_ratio: 0.1
 168 |   }
 169 | }
 170 | layer {
 171 |   name: "conv2_1"
 172 |   type: "Convolution"
 173 |   bottom: "conv2_bn"
 174 |   top: "conv2_1"
 175 |   param {
 176 |     lr_mult: 1
 177 |   }
 178 |   param {
 179 |     lr_mult: 2
 180 |   }
 181 |   convolution_param {
 182 |     num_output: 70
 183 |     pad: 1
 184 |     kernel_size: 3
 185 |     stride: 1
 186 |     weight_filler {
 187 |       type: "xavier"
 188 |     }
 189 |     bias_filler {
 190 |       type: "constant"
 191 |     }
 192 |   }
 193 | }
 194 | layer {
 195 |   name: "relu2"
 196 |   type: "ReLU"
 197 |   bottom: "conv2_1"
 198 |   top: "conv2_1"
 199 | }
 200 | layer {
 201 |   name: "conv2_bn_1"
 202 |   type: "BN"
 203 |   bottom: "conv2_1"
 204 |   top: "conv2_bn_1"
 205 |   param {
 206 |     lr_mult: 1
 207 |     decay_mult: 0
 208 |   }
 209 |   param {
 210 |     lr_mult: 1
 211 |     decay_mult: 0
 212 |   }
 213 |   bn_param {
 214 |     scale_filler {
 215 |       type: "constant"
 216 |       value: 1
 217 |     }
 218 |     shift_filler {
 219 |       type: "constant"
 220 |       value: 0
 221 |     }
 222 |   }
 223 | }
 224 | layer {
 225 |   name: "drop1_1"
 226 |   type: "Dropout"
 227 |   bottom: "conv2_bn_1"
 228 |   top: "conv2_bn_1"
 229 |   dropout_param {
 230 |     dropout_ratio: 0.1
 231 |   }
 232 | }
 233 | layer {
 234 |   name: "pool2"
 235 |   type: "Pooling"
 236 |   bottom: "conv2_bn_1"
 237 |   top: "pool2"
 238 |   pooling_param {
 239 |     pool: MAX
 240 |     kernel_size: 2
 241 |     stride: 2
 242 |   }
 243 | }
 244 | layer {
 245 |   name: "ip1"
 246 |   type: "InnerProduct"
 247 |   bottom: "pool2"
 248 |   top: "ip1"
 249 |   param {
 250 |     lr_mult: 1
 251 |   }
 252 |   param {
 253 |     lr_mult: 2
 254 |   }
 255 |   inner_product_param {
 256 |     num_output: 300
 257 |     weight_filler {
 258 |       type: "xavier"
 259 |     }
 260 |     bias_filler {
 261 |       type: "constant"
 262 |     }
 263 |   }
 264 | }
 265 | layer {
 266 |   name: "relu3"
 267 |   type: "ReLU"
 268 |   bottom: "ip1"
 269 |   top: "ip1"
 270 | }
 271 | layer {
 272 |   name: "drop2"
 273 |   type: "Dropout"
 274 |   bottom: "ip1"
 275 |   top: "ip1"
 276 |   dropout_param {
 277 |     dropout_ratio: 0.3
 278 |   }
 279 | }
 280 | layer {
 281 |   name: "ip3"
 282 |   type: "InnerProduct"
 283 |   bottom: "ip1"
 284 |   top: "ip3"
 285 |   param {
 286 |     lr_mult: 1
 287 |   }
 288 |   param {
 289 |     lr_mult: 2
 290 |   }
 291 |   inner_product_param {
 292 |     num_output: 10
 293 |     weight_filler {
 294 |       type: "xavier"
 295 |     }
 296 |     bias_filler {
 297 |       type: "constant"
 298 |     }
 299 |   }
 300 | }
 301 | layer {
 302 |   name: "loss"
 303 |   type: "SoftmaxWithLoss"
 304 |   bottom: "ip3"
 305 |   bottom: "label"
 306 |   top: "loss"
 307 | }
 308 | I0806 09:45:16.377032 11748 layer_factory.hpp:74] Creating layer mnist
 309 | I0806 09:45:16.378032 11748 net.cpp:90] Creating Layer mnist
 310 | I0806 09:45:16.378032 11748 net.cpp:368] mnist -> data
 311 | I0806 09:45:16.379032 11748 net.cpp:368] mnist -> label
 312 | I0806 09:45:16.379032 11748 net.cpp:120] Setting up mnist
 313 | I0806 09:45:16.386034 11748 db.cpp:20] Opened leveldb mnist-train-leveldb
 314 | I0806 09:45:16.386034 11748 data_layer.cpp:52] output data size: 64,1,28,28
 315 | I0806 09:45:16.387033 11748 net.cpp:127] Top shape: 64 1 28 28 (50176)
 316 | I0806 09:45:16.387033 11748 net.cpp:127] Top shape: 64 (64)
 317 | I0806 09:45:16.387033 11748 layer_factory.hpp:74] Creating layer conv1
 318 | I0806 09:45:16.388033 11748 net.cpp:90] Creating Layer conv1
 319 | I0806 09:45:16.388033 11748 net.cpp:410] conv1 <- data
 320 | I0806 09:45:16.388033 11748 net.cpp:368] conv1 -> conv1
 321 | I0806 09:45:16.388033 11748 net.cpp:120] Setting up conv1
 322 | I0806 09:45:16.389034 11748 common.cpp:24] System entropy source not available, using fallback algorithm to generate seed instead.
 323 | I0806 09:45:16.457037 11748 net.cpp:127] Top shape: 64 30 22 22 (929280)
 324 | I0806 09:45:16.457037 11748 layer_factory.hpp:74] Creating layer relu1
 325 | I0806 09:45:16.458037 11748 net.cpp:90] Creating Layer relu1
 326 | I0806 09:45:16.458037 11748 net.cpp:410] relu1 <- conv1
 327 | I0806 09:45:16.458037 11748 net.cpp:357] relu1 -> conv1 (in-place)
 328 | I0806 09:45:16.459038 11748 net.cpp:120] Setting up relu1
 329 | I0806 09:45:16.459038 11748 net.cpp:127] Top shape: 64 30 22 22 (929280)
 330 | I0806 09:45:16.459038 11748 layer_factory.hpp:74] Creating layer conv1_bn
 331 | I0806 09:45:16.460037 11748 net.cpp:90] Creating Layer conv1_bn
 332 | I0806 09:45:16.460037 11748 net.cpp:410] conv1_bn <- conv1
 333 | I0806 09:45:16.460037 11748 net.cpp:368] conv1_bn -> conv1_bn
 334 | I0806 09:45:16.461037 11748 net.cpp:120] Setting up conv1_bn
 335 | I0806 09:45:16.461037 11748 net.cpp:127] Top shape: 64 30 22 22 (929280)
 336 | I0806 09:45:16.461037 11748 layer_factory.hpp:74] Creating layer pool1
 337 | I0806 09:45:16.462038 11748 net.cpp:90] Creating Layer pool1
 338 | I0806 09:45:16.462038 11748 net.cpp:410] pool1 <- conv1_bn
 339 | I0806 09:45:16.462038 11748 net.cpp:368] pool1 -> pool1
 340 | I0806 09:45:16.463037 11748 net.cpp:120] Setting up pool1
 341 | I0806 09:45:16.463037 11748 net.cpp:127] Top shape: 64 30 11 11 (232320)
 342 | I0806 09:45:16.463037 11748 layer_factory.hpp:74] Creating layer conv2
 343 | I0806 09:45:16.464037 11748 net.cpp:90] Creating Layer conv2
 344 | I0806 09:45:16.464037 11748 net.cpp:410] conv2 <- pool1
 345 | I0806 09:45:16.464037 11748 net.cpp:368] conv2 -> conv2
 346 | I0806 09:45:16.464037 11748 net.cpp:120] Setting up conv2
 347 | I0806 09:45:16.465037 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 348 | I0806 09:45:16.466037 11748 layer_factory.hpp:74] Creating layer relu2
 349 | I0806 09:45:16.466037 11748 net.cpp:90] Creating Layer relu2
 350 | I0806 09:45:16.466037 11748 net.cpp:410] relu2 <- conv2
 351 | I0806 09:45:16.466037 11748 net.cpp:357] relu2 -> conv2 (in-place)
 352 | I0806 09:45:16.467038 11748 net.cpp:120] Setting up relu2
 353 | I0806 09:45:16.467038 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 354 | I0806 09:45:16.467038 11748 layer_factory.hpp:74] Creating layer conv2_bn
 355 | I0806 09:45:16.467038 11748 net.cpp:90] Creating Layer conv2_bn
 356 | I0806 09:45:16.468039 11748 net.cpp:410] conv2_bn <- conv2
 357 | I0806 09:45:16.468039 11748 net.cpp:368] conv2_bn -> conv2_bn
 358 | I0806 09:45:16.468039 11748 net.cpp:120] Setting up conv2_bn
 359 | I0806 09:45:16.468039 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 360 | I0806 09:45:16.469038 11748 layer_factory.hpp:74] Creating layer drop1
 361 | I0806 09:45:16.469038 11748 net.cpp:90] Creating Layer drop1
 362 | I0806 09:45:16.469038 11748 net.cpp:410] drop1 <- conv2_bn
 363 | I0806 09:45:16.469038 11748 net.cpp:357] drop1 -> conv2_bn (in-place)
 364 | I0806 09:45:16.470038 11748 net.cpp:120] Setting up drop1
 365 | I0806 09:45:16.470038 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 366 | I0806 09:45:16.470038 11748 layer_factory.hpp:74] Creating layer conv2_1
 367 | I0806 09:45:16.470038 11748 net.cpp:90] Creating Layer conv2_1
 368 | I0806 09:45:16.471038 11748 net.cpp:410] conv2_1 <- conv2_bn
 369 | I0806 09:45:16.471038 11748 net.cpp:368] conv2_1 -> conv2_1
 370 | I0806 09:45:16.471038 11748 net.cpp:120] Setting up conv2_1
 371 | I0806 09:45:16.472038 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 372 | I0806 09:45:16.472038 11748 layer_factory.hpp:74] Creating layer relu2
 373 | I0806 09:45:16.473038 11748 net.cpp:90] Creating Layer relu2
 374 | I0806 09:45:16.473038 11748 net.cpp:410] relu2 <- conv2_1
 375 | I0806 09:45:16.473038 11748 net.cpp:357] relu2 -> conv2_1 (in-place)
 376 | I0806 09:45:16.473038 11748 net.cpp:120] Setting up relu2
 377 | I0806 09:45:16.474038 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 378 | I0806 09:45:16.474038 11748 layer_factory.hpp:74] Creating layer conv2_bn_1
 379 | I0806 09:45:16.474038 11748 net.cpp:90] Creating Layer conv2_bn_1
 380 | I0806 09:45:16.475039 11748 net.cpp:410] conv2_bn_1 <- conv2_1
 381 | I0806 09:45:16.475039 11748 net.cpp:368] conv2_bn_1 -> conv2_bn_1
 382 | I0806 09:45:16.475039 11748 net.cpp:120] Setting up conv2_bn_1
 383 | I0806 09:45:16.475039 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 384 | I0806 09:45:16.476038 11748 layer_factory.hpp:74] Creating layer drop1_1
 385 | I0806 09:45:16.476038 11748 net.cpp:90] Creating Layer drop1_1
 386 | I0806 09:45:16.476038 11748 net.cpp:410] drop1_1 <- conv2_bn_1
 387 | I0806 09:45:16.476038 11748 net.cpp:357] drop1_1 -> conv2_bn_1 (in-place)
 388 | I0806 09:45:16.476038 11748 net.cpp:120] Setting up drop1_1
 389 | I0806 09:45:16.477038 11748 net.cpp:127] Top shape: 64 70 9 9 (362880)
 390 | I0806 09:45:16.477038 11748 layer_factory.hpp:74] Creating layer pool2
 391 | I0806 09:45:16.477038 11748 net.cpp:90] Creating Layer pool2
 392 | I0806 09:45:16.477038 11748 net.cpp:410] pool2 <- conv2_bn_1
 393 | I0806 09:45:16.478039 11748 net.cpp:368] pool2 -> pool2
 394 | I0806 09:45:16.478039 11748 net.cpp:120] Setting up pool2
 395 | I0806 09:45:16.478039 11748 net.cpp:127] Top shape: 64 70 5 5 (112000)
 396 | I0806 09:45:16.479038 11748 layer_factory.hpp:74] Creating layer ip1
 397 | I0806 09:45:16.479038 11748 net.cpp:90] Creating Layer ip1
 398 | I0806 09:45:16.479038 11748 net.cpp:410] ip1 <- pool2
 399 | I0806 09:45:16.480038 11748 net.cpp:368] ip1 -> ip1
 400 | I0806 09:45:16.480038 11748 net.cpp:120] Setting up ip1
 401 | I0806 09:45:16.484038 11748 net.cpp:127] Top shape: 64 300 (19200)
 402 | I0806 09:45:16.484038 11748 layer_factory.hpp:74] Creating layer relu3
 403 | I0806 09:45:16.484038 11748 net.cpp:90] Creating Layer relu3
 404 | I0806 09:45:16.485039 11748 net.cpp:410] relu3 <- ip1
 405 | I0806 09:45:16.485039 11748 net.cpp:357] relu3 -> ip1 (in-place)
 406 | I0806 09:45:16.485039 11748 net.cpp:120] Setting up relu3
 407 | I0806 09:45:16.486039 11748 net.cpp:127] Top shape: 64 300 (19200)
 408 | I0806 09:45:16.486039 11748 layer_factory.hpp:74] Creating layer drop2
 409 | I0806 09:45:16.486039 11748 net.cpp:90] Creating Layer drop2
 410 | I0806 09:45:16.486039 11748 net.cpp:410] drop2 <- ip1
 411 | I0806 09:45:16.487040 11748 net.cpp:357] drop2 -> ip1 (in-place)
 412 | I0806 09:45:16.487040 11748 net.cpp:120] Setting up drop2
 413 | I0806 09:45:16.487040 11748 net.cpp:127] Top shape: 64 300 (19200)
 414 | I0806 09:45:16.487040 11748 layer_factory.hpp:74] Creating layer ip3
 415 | I0806 09:45:16.487040 11748 net.cpp:90] Creating Layer ip3
 416 | I0806 09:45:16.488039 11748 net.cpp:410] ip3 <- ip1
 417 | I0806 09:45:16.488039 11748 net.cpp:368] ip3 -> ip3
 418 | I0806 09:45:16.488039 11748 net.cpp:120] Setting up ip3
 419 | I0806 09:45:16.488039 11748 net.cpp:127] Top shape: 64 10 (640)
 420 | I0806 09:45:16.489039 11748 layer_factory.hpp:74] Creating layer loss
 421 | I0806 09:45:16.489039 11748 net.cpp:90] Creating Layer loss
 422 | I0806 09:45:16.489039 11748 net.cpp:410] loss <- ip3
 423 | I0806 09:45:16.489039 11748 net.cpp:410] loss <- label
 424 | I0806 09:45:16.490039 11748 net.cpp:368] loss -> loss
 425 | I0806 09:45:16.490039 11748 net.cpp:120] Setting up loss
 426 | I0806 09:45:16.490039 11748 layer_factory.hpp:74] Creating layer loss
 427 | I0806 09:45:16.491039 11748 net.cpp:127] Top shape: (1)
 428 | I0806 09:45:16.491039 11748 net.cpp:129]     with loss weight 1
 429 | I0806 09:45:16.491039 11748 net.cpp:192] loss needs backward computation.
 430 | I0806 09:45:16.491039 11748 net.cpp:192] ip3 needs backward computation.
 431 | I0806 09:45:16.492039 11748 net.cpp:192] drop2 needs backward computation.
 432 | I0806 09:45:16.492039 11748 net.cpp:192] relu3 needs backward computation.
 433 | I0806 09:45:16.492039 11748 net.cpp:192] ip1 needs backward computation.
 434 | I0806 09:45:16.492039 11748 net.cpp:192] pool2 needs backward computation.
 435 | I0806 09:45:16.493039 11748 net.cpp:192] drop1_1 needs backward computation.
 436 | I0806 09:45:16.493039 11748 net.cpp:192] conv2_bn_1 needs backward computation.
 437 | I0806 09:45:16.493039 11748 net.cpp:192] relu2 needs backward computation.
 438 | I0806 09:45:16.493039 11748 net.cpp:192] conv2_1 needs backward computation.
 439 | I0806 09:45:16.494040 11748 net.cpp:192] drop1 needs backward computation.
 440 | I0806 09:45:16.494040 11748 net.cpp:192] conv2_bn needs backward computation.
 441 | I0806 09:45:16.494040 11748 net.cpp:192] relu2 needs backward computation.
 442 | I0806 09:45:16.494040 11748 net.cpp:192] conv2 needs backward computation.
 443 | I0806 09:45:16.494040 11748 net.cpp:192] pool1 needs backward computation.
 444 | I0806 09:45:16.495039 11748 net.cpp:192] conv1_bn needs backward computation.
 445 | I0806 09:45:16.495039 11748 net.cpp:192] relu1 needs backward computation.
 446 | I0806 09:45:16.495039 11748 net.cpp:192] conv1 needs backward computation.
 447 | I0806 09:45:16.495039 11748 net.cpp:194] mnist does not need backward computation.
 448 | I0806 09:45:16.496039 11748 net.cpp:235] This network produces output loss
 449 | I0806 09:45:16.496039 11748 net.cpp:482] Collecting Learning Rate and Weight Decay.
 450 | I0806 09:45:16.496039 11748 net.cpp:247] Network initialization done.
 451 | I0806 09:45:16.497040 11748 net.cpp:248] Memory required for data: 24574724
 452 | I0806 09:45:16.497040 11748 solver.cpp:154] Creating test net (#0) specified by net file: lenet_train_test.prototxt
 453 | I0806 09:45:16.498039 11748 net.cpp:287] The NetState phase (1) differed from the phase (0) specified by a rule in layer mnist
 454 | I0806 09:45:16.498039 11748 net.cpp:42] Initializing net from parameters: 
 455 | name: "LeNet"
 456 | state {
 457 |   phase: TEST
 458 | }
 459 | layer {
 460 |   name: "mnist"
 461 |   type: "Data"
 462 |   top: "data"
 463 |   top: "label"
 464 |   include {
 465 |     phase: TEST
 466 |   }
 467 |   transform_param {
 468 |     scale: 0.00390625
 469 |   }
 470 |   data_param {
 471 |     source: "mnist-test-leveldb"
 472 |     batch_size: 100
 473 |     backend: LEVELDB
 474 |   }
 475 | }
 476 | layer {
 477 |   name: "conv1"
 478 |   type: "Convolution"
 479 |   bottom: "data"
 480 |   top: "conv1"
 481 |   param {
 482 |     lr_mult: 1
 483 |   }
 484 |   param {
 485 |     lr_mult: 2
 486 |   }
 487 |   convolution_param {
 488 |     num_output: 30
 489 |     kernel_size: 7
 490 |     stride: 1
 491 |     weight_filler {
 492 |       type: "xavier"
 493 |     }
 494 |     bias_filler {
 495 |       type: "constant"
 496 |     }
 497 |   }
 498 | }
 499 | layer {
 500 |   name: "relu1"
 501 |   type: "ReLU"
 502 |   bottom: "conv1"
 503 |   top: "conv1"
 504 | }
 505 | layer {
 506 |   name: "conv1_bn"
 507 |   type: "BN"
 508 |   bottom: "conv1"
 509 |   top: "conv1_bn"
 510 |   param {
 511 |     lr_mult: 1
 512 |     decay_mult: 0
 513 |   }
 514 |   param {
 515 |     lr_mult: 1
 516 |     decay_mult: 0
 517 |   }
 518 |   bn_param {
 519 |     scale_filler {
 520 |       type: "constant"
 521 |       value: 1
 522 |     }
 523 |     shift_filler {
 524 |       type: "constant"
 525 |       value: 0
 526 |     }
 527 |   }
 528 | }
 529 | layer {
 530 |   name: "pool1"
 531 |   type: "Pooling"
 532 |   bottom: "conv1_bn"
 533 |   top: "pool1"
 534 |   pooling_param {
 535 |     pool: MAX
 536 |     kernel_size: 2
 537 |     stride: 2
 538 |   }
 539 | }
 540 | layer {
 541 |   name: "conv2"
 542 |   type: "Convolution"
 543 |   bottom: "pool1"
 544 |   top: "conv2"
 545 |   param {
 546 |     lr_mult: 1
 547 |   }
 548 |   param {
 549 |     lr_mult: 2
 550 |   }
 551 |   convolution_param {
 552 |     num_output: 70
 553 |     kernel_size: 3
 554 |     stride: 1
 555 |     weight_filler {
 556 |       type: "xavier"
 557 |     }
 558 |     bias_filler {
 559 |       type: "constant"
 560 |     }
 561 |   }
 562 | }
 563 | layer {
 564 |   name: "relu2"
 565 |   type: "ReLU"
 566 |   bottom: "conv2"
 567 |   top: "conv2"
 568 | }
 569 | layer {
 570 |   name: "conv2_bn"
 571 |   type: "BN"
 572 |   bottom: "conv2"
 573 |   top: "conv2_bn"
 574 |   param {
 575 |     lr_mult: 1
 576 |     decay_mult: 0
 577 |   }
 578 |   param {
 579 |     lr_mult: 1
 580 |     decay_mult: 0
 581 |   }
 582 |   bn_param {
 583 |     scale_filler {
 584 |       type: "constant"
 585 |       value: 1
 586 |     }
 587 |     shift_filler {
 588 |       type: "constant"
 589 |       value: 0
 590 |     }
 591 |   }
 592 | }
 593 | layer {
 594 |   name: "drop1"
 595 |   type: "Dropout"
 596 |   bottom: "conv2_bn"
 597 |   top: "conv2_bn"
 598 |   dropout_param {
 599 |     dropout_ratio: 0.1
 600 |   }
 601 | }
 602 | layer {
 603 |   name: "conv2_1"
 604 |   type: "Convolution"
 605 |   bottom: "conv2_bn"
 606 |   top: "conv2_1"
 607 |   param {
 608 |     lr_mult: 1
 609 |   }
 610 |   param {
 611 |     lr_mult: 2
 612 |   }
 613 |   convolution_param {
 614 |     num_output: 70
 615 |     pad: 1
 616 |     kernel_size: 3
 617 |     stride: 1
 618 |     weight_filler {
 619 |       type: "xavier"
 620 |     }
 621 |     bias_filler {
 622 |       type: "constant"
 623 |     }
 624 |   }
 625 | }
 626 | layer {
 627 |   name: "relu2"
 628 |   type: "ReLU"
 629 |   bottom: "conv2_1"
 630 |   top: "conv2_1"
 631 | }
 632 | layer {
 633 |   name: "conv2_bn_1"
 634 |   type: "BN"
 635 |   bottom: "conv2_1"
 636 |   top: "conv2_bn_1"
 637 |   param {
 638 |     lr_mult: 1
 639 |     decay_mult: 0
 640 |   }
 641 |   param {
 642 |     lr_mult: 1
 643 |     decay_mult: 0
 644 |   }
 645 |   bn_param {
 646 |     scale_filler {
 647 |       type: "constant"
 648 |       value: 1
 649 |     }
 650 |     shift_filler {
 651 |       type: "constant"
 652 |       value: 0
 653 |     }
 654 |   }
 655 | }
 656 | layer {
 657 |   name: "drop1_1"
 658 |   type: "Dropout"
 659 |   bottom: "conv2_bn_1"
 660 |   top: "conv2_bn_1"
 661 |   dropout_param {
 662 |     dropout_ratio: 0.1
 663 |   }
 664 | }
 665 | layer {
 666 |   name: "pool2"
 667 |   type: "Pooling"
 668 |   bottom: "conv2_bn_1"
 669 |   top: "pool2"
 670 |   pooling_param {
 671 |     pool: MAX
 672 |     kernel_size: 2
 673 |     stride: 2
 674 |   }
 675 | }
 676 | layer {
 677 |   name: "ip1"
 678 |   type: "InnerProduct"
 679 |   bottom: "pool2"
 680 |   top: "ip1"
 681 |   param {
 682 |     lr_mult: 1
 683 |   }
 684 |   param {
 685 |     lr_mult: 2
 686 |   }
 687 |   inner_product_param {
 688 |     num_output: 300
 689 |     weight_filler {
 690 |       type: "xavier"
 691 |     }
 692 |     bias_filler {
 693 |       type: "constant"
 694 |     }
 695 |   }
 696 | }
 697 | layer {
 698 |   name: "relu3"
 699 |   type: "ReLU"
 700 |   bottom: "ip1"
 701 |   top: "ip1"
 702 | }
 703 | layer {
 704 |   name: "drop2"
 705 |   type: "Dropout"
 706 |   bottom: "ip1"
 707 |   top: "ip1"
 708 |   dropout_param {
 709 |     dropout_ratio: 0.3
 710 |   }
 711 | }
 712 | layer {
 713 |   name: "ip3"
 714 |   type: "InnerProduct"
 715 |   bottom: "ip1"
 716 |   top: "ip3"
 717 |   param {
 718 |     lr_mult: 1
 719 |   }
 720 |   param {
 721 |     lr_mult: 2
 722 |   }
 723 |   inner_product_param {
 724 |     num_output: 10
 725 |     weight_filler {
 726 |       type: "xavier"
 727 |     }
 728 |     bias_filler {
 729 |       type: "constant"
 730 |     }
 731 |   }
 732 | }
 733 | layer {
 734 |   name: "accuracy"
 735 |   type: "Accuracy"
 736 |   bottom: "ip3"
 737 |   bottom: "label"
 738 |   top: "accuracy"
 739 |   include {
 740 |     phase: TEST
 741 |   }
 742 | }
 743 | layer {
 744 |   name: "loss"
 745 |   type: "SoftmaxWithLoss"
 746 |   bottom: "ip3"
 747 |   bottom: "label"
 748 |   top: "loss"
 749 | }
 750 | I0806 09:45:16.529042 11748 layer_factory.hpp:74] Creating layer mnist
 751 | I0806 09:45:16.530041 11748 net.cpp:90] Creating Layer mnist
 752 | I0806 09:45:16.530041 11748 net.cpp:368] mnist -> data
 753 | I0806 09:45:16.530041 11748 net.cpp:368] mnist -> label
 754 | I0806 09:45:16.531041 11748 net.cpp:120] Setting up mnist
 755 | I0806 09:45:16.538043 11748 db.cpp:20] Opened leveldb mnist-test-leveldb
 756 | I0806 09:45:16.539042 11748 data_layer.cpp:52] output data size: 100,1,28,28
 757 | I0806 09:45:16.539042 11748 net.cpp:127] Top shape: 100 1 28 28 (78400)
 758 | I0806 09:45:16.540042 11748 net.cpp:127] Top shape: 100 (100)
 759 | I0806 09:45:16.540042 11748 layer_factory.hpp:74] Creating layer label_mnist_1_split
 760 | I0806 09:45:16.540042 11748 net.cpp:90] Creating Layer label_mnist_1_split
 761 | I0806 09:45:16.541043 11748 net.cpp:410] label_mnist_1_split <- label
 762 | I0806 09:45:16.541043 11748 net.cpp:368] label_mnist_1_split -> label_mnist_1_split_0
 763 | I0806 09:45:16.541043 11748 net.cpp:368] label_mnist_1_split -> label_mnist_1_split_1
 764 | I0806 09:45:16.542042 11748 net.cpp:120] Setting up label_mnist_1_split
 765 | I0806 09:45:16.542042 11748 net.cpp:127] Top shape: 100 (100)
 766 | I0806 09:45:16.542042 11748 net.cpp:127] Top shape: 100 (100)
 767 | I0806 09:45:16.542042 11748 layer_factory.hpp:74] Creating layer conv1
 768 | I0806 09:45:16.543042 11748 net.cpp:90] Creating Layer conv1
 769 | I0806 09:45:16.543042 11748 net.cpp:410] conv1 <- data
 770 | I0806 09:45:16.543042 11748 net.cpp:368] conv1 -> conv1
 771 | I0806 09:45:16.543042 11748 net.cpp:120] Setting up conv1
 772 | I0806 09:45:16.544042 11748 net.cpp:127] Top shape: 100 30 22 22 (1452000)
 773 | I0806 09:45:16.545042 11748 layer_factory.hpp:74] Creating layer relu1
 774 | I0806 09:45:16.545042 11748 net.cpp:90] Creating Layer relu1
 775 | I0806 09:45:16.545042 11748 net.cpp:410] relu1 <- conv1
 776 | I0806 09:45:16.545042 11748 net.cpp:357] relu1 -> conv1 (in-place)
 777 | I0806 09:45:16.546042 11748 net.cpp:120] Setting up relu1
 778 | I0806 09:45:16.546042 11748 net.cpp:127] Top shape: 100 30 22 22 (1452000)
 779 | I0806 09:45:16.547042 11748 layer_factory.hpp:74] Creating layer conv1_bn
 780 | I0806 09:45:16.547042 11748 net.cpp:90] Creating Layer conv1_bn
 781 | I0806 09:45:16.547042 11748 net.cpp:410] conv1_bn <- conv1
 782 | I0806 09:45:16.547042 11748 net.cpp:368] conv1_bn -> conv1_bn
 783 | I0806 09:45:16.548043 11748 net.cpp:120] Setting up conv1_bn
 784 | I0806 09:45:16.548043 11748 net.cpp:127] Top shape: 100 30 22 22 (1452000)
 785 | I0806 09:45:16.548043 11748 layer_factory.hpp:74] Creating layer pool1
 786 | I0806 09:45:16.548043 11748 net.cpp:90] Creating Layer pool1
 787 | I0806 09:45:16.549042 11748 net.cpp:410] pool1 <- conv1_bn
 788 | I0806 09:45:16.549042 11748 net.cpp:368] pool1 -> pool1
 789 | I0806 09:45:16.549042 11748 net.cpp:120] Setting up pool1
 790 | I0806 09:45:16.549042 11748 net.cpp:127] Top shape: 100 30 11 11 (363000)
 791 | I0806 09:45:16.550042 11748 layer_factory.hpp:74] Creating layer conv2
 792 | I0806 09:45:16.550042 11748 net.cpp:90] Creating Layer conv2
 793 | I0806 09:45:16.550042 11748 net.cpp:410] conv2 <- pool1
 794 | I0806 09:45:16.550042 11748 net.cpp:368] conv2 -> conv2
 795 | I0806 09:45:16.550042 11748 net.cpp:120] Setting up conv2
 796 | I0806 09:45:16.551043 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 797 | I0806 09:45:16.551043 11748 layer_factory.hpp:74] Creating layer relu2
 798 | I0806 09:45:16.552042 11748 net.cpp:90] Creating Layer relu2
 799 | I0806 09:45:16.552042 11748 net.cpp:410] relu2 <- conv2
 800 | I0806 09:45:16.553042 11748 net.cpp:357] relu2 -> conv2 (in-place)
 801 | I0806 09:45:16.553042 11748 net.cpp:120] Setting up relu2
 802 | I0806 09:45:16.553042 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 803 | I0806 09:45:16.554042 11748 layer_factory.hpp:74] Creating layer conv2_bn
 804 | I0806 09:45:16.554042 11748 net.cpp:90] Creating Layer conv2_bn
 805 | I0806 09:45:16.554042 11748 net.cpp:410] conv2_bn <- conv2
 806 | I0806 09:45:16.554042 11748 net.cpp:368] conv2_bn -> conv2_bn
 807 | I0806 09:45:16.555043 11748 net.cpp:120] Setting up conv2_bn
 808 | I0806 09:45:16.555043 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 809 | I0806 09:45:16.555043 11748 layer_factory.hpp:74] Creating layer drop1
 810 | I0806 09:45:16.556043 11748 net.cpp:90] Creating Layer drop1
 811 | I0806 09:45:16.556043 11748 net.cpp:410] drop1 <- conv2_bn
 812 | I0806 09:45:16.556043 11748 net.cpp:357] drop1 -> conv2_bn (in-place)
 813 | I0806 09:45:16.556043 11748 net.cpp:120] Setting up drop1
 814 | I0806 09:45:16.557044 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 815 | I0806 09:45:16.557044 11748 layer_factory.hpp:74] Creating layer conv2_1
 816 | I0806 09:45:16.557044 11748 net.cpp:90] Creating Layer conv2_1
 817 | I0806 09:45:16.557044 11748 net.cpp:410] conv2_1 <- conv2_bn
 818 | I0806 09:45:16.558043 11748 net.cpp:368] conv2_1 -> conv2_1
 819 | I0806 09:45:16.558043 11748 net.cpp:120] Setting up conv2_1
 820 | I0806 09:45:16.559043 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 821 | I0806 09:45:16.559043 11748 layer_factory.hpp:74] Creating layer relu2
 822 | I0806 09:45:16.559043 11748 net.cpp:90] Creating Layer relu2
 823 | I0806 09:45:16.560044 11748 net.cpp:410] relu2 <- conv2_1
 824 | I0806 09:45:16.560044 11748 net.cpp:357] relu2 -> conv2_1 (in-place)
 825 | I0806 09:45:16.560044 11748 net.cpp:120] Setting up relu2
 826 | I0806 09:45:16.560044 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 827 | I0806 09:45:16.561043 11748 layer_factory.hpp:74] Creating layer conv2_bn_1
 828 | I0806 09:45:16.561043 11748 net.cpp:90] Creating Layer conv2_bn_1
 829 | I0806 09:45:16.561043 11748 net.cpp:410] conv2_bn_1 <- conv2_1
 830 | I0806 09:45:16.562043 11748 net.cpp:368] conv2_bn_1 -> conv2_bn_1
 831 | I0806 09:45:16.562043 11748 net.cpp:120] Setting up conv2_bn_1
 832 | I0806 09:45:16.562043 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 833 | I0806 09:45:16.562043 11748 layer_factory.hpp:74] Creating layer drop1_1
 834 | I0806 09:45:16.562043 11748 net.cpp:90] Creating Layer drop1_1
 835 | I0806 09:45:16.563043 11748 net.cpp:410] drop1_1 <- conv2_bn_1
 836 | I0806 09:45:16.563043 11748 net.cpp:357] drop1_1 -> conv2_bn_1 (in-place)
 837 | I0806 09:45:16.563043 11748 net.cpp:120] Setting up drop1_1
 838 | I0806 09:45:16.563043 11748 net.cpp:127] Top shape: 100 70 9 9 (567000)
 839 | I0806 09:45:16.564043 11748 layer_factory.hpp:74] Creating layer pool2
 840 | I0806 09:45:16.564043 11748 net.cpp:90] Creating Layer pool2
 841 | I0806 09:45:16.564043 11748 net.cpp:410] pool2 <- conv2_bn_1
 842 | I0806 09:45:16.565043 11748 net.cpp:368] pool2 -> pool2
 843 | I0806 09:45:16.565043 11748 net.cpp:120] Setting up pool2
 844 | I0806 09:45:16.565043 11748 net.cpp:127] Top shape: 100 70 5 5 (175000)
 845 | I0806 09:45:16.566043 11748 layer_factory.hpp:74] Creating layer ip1
 846 | I0806 09:45:16.566043 11748 net.cpp:90] Creating Layer ip1
 847 | I0806 09:45:16.566043 11748 net.cpp:410] ip1 <- pool2
 848 | I0806 09:45:16.566043 11748 net.cpp:368] ip1 -> ip1
 849 | I0806 09:45:16.567044 11748 net.cpp:120] Setting up ip1
 850 | I0806 09:45:16.570044 11748 net.cpp:127] Top shape: 100 300 (30000)
 851 | I0806 09:45:16.571043 11748 layer_factory.hpp:74] Creating layer relu3
 852 | I0806 09:45:16.571043 11748 net.cpp:90] Creating Layer relu3
 853 | I0806 09:45:16.571043 11748 net.cpp:410] relu3 <- ip1
 854 | I0806 09:45:16.572044 11748 net.cpp:357] relu3 -> ip1 (in-place)
 855 | I0806 09:45:16.572044 11748 net.cpp:120] Setting up relu3
 856 | I0806 09:45:16.572044 11748 net.cpp:127] Top shape: 100 300 (30000)
 857 | I0806 09:45:16.573045 11748 layer_factory.hpp:74] Creating layer drop2
 858 | I0806 09:45:16.573045 11748 net.cpp:90] Creating Layer drop2
 859 | I0806 09:45:16.573045 11748 net.cpp:410] drop2 <- ip1
 860 | I0806 09:45:16.573045 11748 net.cpp:357] drop2 -> ip1 (in-place)
 861 | I0806 09:45:16.574044 11748 net.cpp:120] Setting up drop2
 862 | I0806 09:45:16.574044 11748 net.cpp:127] Top shape: 100 300 (30000)
 863 | I0806 09:45:16.574044 11748 layer_factory.hpp:74] Creating layer ip3
 864 | I0806 09:45:16.574044 11748 net.cpp:90] Creating Layer ip3
 865 | I0806 09:45:16.575044 11748 net.cpp:410] ip3 <- ip1
 866 | I0806 09:45:16.575044 11748 net.cpp:368] ip3 -> ip3
 867 | I0806 09:45:16.575044 11748 net.cpp:120] Setting up ip3
 868 | I0806 09:45:16.575044 11748 net.cpp:127] Top shape: 100 10 (1000)
 869 | I0806 09:45:16.576045 11748 layer_factory.hpp:74] Creating layer ip3_ip3_0_split
 870 | I0806 09:45:16.576045 11748 net.cpp:90] Creating Layer ip3_ip3_0_split
 871 | I0806 09:45:16.576045 11748 net.cpp:410] ip3_ip3_0_split <- ip3
 872 | I0806 09:45:16.576045 11748 net.cpp:368] ip3_ip3_0_split -> ip3_ip3_0_split_0
 873 | I0806 09:45:16.577044 11748 net.cpp:368] ip3_ip3_0_split -> ip3_ip3_0_split_1
 874 | I0806 09:45:16.577044 11748 net.cpp:120] Setting up ip3_ip3_0_split
 875 | I0806 09:45:16.577044 11748 net.cpp:127] Top shape: 100 10 (1000)
 876 | I0806 09:45:16.577044 11748 net.cpp:127] Top shape: 100 10 (1000)
 877 | I0806 09:45:16.578044 11748 layer_factory.hpp:74] Creating layer accuracy
 878 | I0806 09:45:16.578044 11748 net.cpp:90] Creating Layer accuracy
 879 | I0806 09:45:16.578044 11748 net.cpp:410] accuracy <- ip3_ip3_0_split_0
 880 | I0806 09:45:16.578044 11748 net.cpp:410] accuracy <- label_mnist_1_split_0
 881 | I0806 09:45:16.579044 11748 net.cpp:368] accuracy -> accuracy
 882 | I0806 09:45:16.579044 11748 net.cpp:120] Setting up accuracy
 883 | I0806 09:45:16.579044 11748 net.cpp:127] Top shape: (1)
 884 | I0806 09:45:16.579044 11748 layer_factory.hpp:74] Creating layer loss
 885 | I0806 09:45:16.580044 11748 net.cpp:90] Creating Layer loss
 886 | I0806 09:45:16.580044 11748 net.cpp:410] loss <- ip3_ip3_0_split_1
 887 | I0806 09:45:16.580044 11748 net.cpp:410] loss <- label_mnist_1_split_1
 888 | I0806 09:45:16.580044 11748 net.cpp:368] loss -> loss
 889 | I0806 09:45:16.580044 11748 net.cpp:120] Setting up loss
 890 | I0806 09:45:16.581044 11748 layer_factory.hpp:74] Creating layer loss
 891 | I0806 09:45:16.581044 11748 net.cpp:127] Top shape: (1)
 892 | I0806 09:45:16.581044 11748 net.cpp:129]     with loss weight 1
 893 | I0806 09:45:16.581044 11748 net.cpp:192] loss needs backward computation.
 894 | I0806 09:45:16.582044 11748 net.cpp:194] accuracy does not need backward computation.
 895 | I0806 09:45:16.582044 11748 net.cpp:192] ip3_ip3_0_split needs backward computation.
 896 | I0806 09:45:16.582044 11748 net.cpp:192] ip3 needs backward computation.
 897 | I0806 09:45:16.582044 11748 net.cpp:192] drop2 needs backward computation.
 898 | I0806 09:45:16.583045 11748 net.cpp:192] relu3 needs backward computation.
 899 | I0806 09:45:16.583045 11748 net.cpp:192] ip1 needs backward computation.
 900 | I0806 09:45:16.583045 11748 net.cpp:192] pool2 needs backward computation.
 901 | I0806 09:45:16.583045 11748 net.cpp:192] drop1_1 needs backward computation.
 902 | I0806 09:45:16.584044 11748 net.cpp:192] conv2_bn_1 needs backward computation.
 903 | I0806 09:45:16.584044 11748 net.cpp:192] relu2 needs backward computation.
 904 | I0806 09:45:16.584044 11748 net.cpp:192] conv2_1 needs backward computation.
 905 | I0806 09:45:16.585044 11748 net.cpp:192] drop1 needs backward computation.
 906 | I0806 09:45:16.585044 11748 net.cpp:192] conv2_bn needs backward computation.
 907 | I0806 09:45:16.585044 11748 net.cpp:192] relu2 needs backward computation.
 908 | I0806 09:45:16.585044 11748 net.cpp:192] conv2 needs backward computation.
 909 | I0806 09:45:16.586045 11748 net.cpp:192] pool1 needs backward computation.
 910 | I0806 09:45:16.586045 11748 net.cpp:192] conv1_bn needs backward computation.
 911 | I0806 09:45:16.586045 11748 net.cpp:192] relu1 needs backward computation.
 912 | I0806 09:45:16.586045 11748 net.cpp:192] conv1 needs backward computation.
 913 | I0806 09:45:16.587044 11748 net.cpp:194] label_mnist_1_split does not need backward computation.
 914 | I0806 09:45:16.587044 11748 net.cpp:194] mnist does not need backward computation.
 915 | I0806 09:45:16.587044 11748 net.cpp:235] This network produces output accuracy
 916 | I0806 09:45:16.588044 11748 net.cpp:235] This network produces output loss
 917 | I0806 09:45:16.588044 11748 net.cpp:482] Collecting Learning Rate and Weight Decay.
 918 | I0806 09:45:16.588044 11748 net.cpp:247] Network initialization done.
 919 | I0806 09:45:16.588044 11748 net.cpp:248] Memory required for data: 38406808
 920 | I0806 09:45:16.589045 11748 solver.cpp:42] Solver scaffolding done.
 921 | I0806 09:45:16.589045 11748 solver.cpp:250] Solving LeNet
 922 | I0806 09:45:16.589045 11748 solver.cpp:251] Learning Rate Policy: step
 923 | I0806 09:45:16.591045 11748 solver.cpp:294] Iteration 0, Testing net (#0)
 924 | I0806 09:45:17.155077 11748 solver.cpp:343]     Test net output #0: accuracy = 0.0602
 925 | I0806 09:45:17.155077 11748 solver.cpp:343]     Test net output #1: loss = 82.0789 (* 1 = 82.0789 loss)
 926 | I0806 09:45:17.179078 11748 solver.cpp:214] Iteration 0, loss = 3.0437
 927 | I0806 09:45:17.180078 11748 solver.cpp:229]     Train net output #0: loss = 3.0437 (* 1 = 3.0437 loss)
 928 | I0806 09:45:17.181078 11748 solver.cpp:486] Iteration 0, lr = 0.04
 929 | I0806 09:45:18.149134 11748 solver.cpp:214] Iteration 100, loss = 0.113036
 930 | I0806 09:45:18.149134 11748 solver.cpp:229]     Train net output #0: loss = 0.113036 (* 1 = 0.113036 loss)
 931 | I0806 09:45:18.150135 11748 solver.cpp:486] Iteration 100, lr = 0.04
 932 | I0806 09:45:19.121189 11748 solver.cpp:214] Iteration 200, loss = 0.0645544
 933 | I0806 09:45:19.122189 11748 solver.cpp:229]     Train net output #0: loss = 0.0645544 (* 1 = 0.0645544 loss)
 934 | I0806 09:45:19.122189 11748 solver.cpp:486] Iteration 200, lr = 0.04
 935 | I0806 09:45:20.095245 11748 solver.cpp:214] Iteration 300, loss = 0.101794
 936 | I0806 09:45:20.095245 11748 solver.cpp:229]     Train net output #0: loss = 0.101794 (* 1 = 0.101794 loss)
 937 | I0806 09:45:20.096246 11748 solver.cpp:486] Iteration 300, lr = 0.04
 938 | I0806 09:45:21.066301 11748 solver.cpp:214] Iteration 400, loss = 0.0546454
 939 | I0806 09:45:21.067301 11748 solver.cpp:229]     Train net output #0: loss = 0.0546455 (* 1 = 0.0546455 loss)
 940 | I0806 09:45:21.067301 11748 solver.cpp:486] Iteration 400, lr = 0.04
 941 | I0806 09:45:22.036356 11748 solver.cpp:214] Iteration 500, loss = 0.0764314
 942 | I0806 09:45:22.036356 11748 solver.cpp:229]     Train net output #0: loss = 0.0764315 (* 1 = 0.0764315 loss)
 943 | I0806 09:45:22.037356 11748 solver.cpp:486] Iteration 500, lr = 0.04
 944 | I0806 09:45:23.016412 11748 solver.cpp:214] Iteration 600, loss = 0.0923337
 945 | I0806 09:45:23.017412 11748 solver.cpp:229]     Train net output #0: loss = 0.0923337 (* 1 = 0.0923337 loss)
 946 | I0806 09:45:23.017412 11748 solver.cpp:486] Iteration 600, lr = 0.04
 947 | I0806 09:45:23.988468 11748 solver.cpp:214] Iteration 700, loss = 0.10121
 948 | I0806 09:45:23.989469 11748 solver.cpp:229]     Train net output #0: loss = 0.10121 (* 1 = 0.10121 loss)
 949 | I0806 09:45:23.990468 11748 solver.cpp:486] Iteration 700, lr = 0.04
 950 | I0806 09:45:24.971524 11748 solver.cpp:214] Iteration 800, loss = 0.257519
 951 | I0806 09:45:24.971524 11748 solver.cpp:229]     Train net output #0: loss = 0.25752 (* 1 = 0.25752 loss)
 952 | I0806 09:45:24.972524 11748 solver.cpp:486] Iteration 800, lr = 0.04
 953 | I0806 09:45:25.956580 11748 solver.cpp:214] Iteration 900, loss = 0.112153
 954 | I0806 09:45:25.957581 11748 solver.cpp:229]     Train net output #0: loss = 0.112154 (* 1 = 0.112154 loss)
 955 | I0806 09:45:25.958580 11748 solver.cpp:486] Iteration 900, lr = 0.04
 956 | I0806 09:45:26.944638 11748 solver.cpp:294] Iteration 1000, Testing net (#0)
 957 | I0806 09:45:27.495668 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9851
 958 | I0806 09:45:27.495668 11748 solver.cpp:343]     Test net output #1: loss = 0.0464547 (* 1 = 0.0464547 loss)
 959 | I0806 09:45:27.501669 11748 solver.cpp:214] Iteration 1000, loss = 0.0401987
 960 | I0806 09:45:27.501669 11748 solver.cpp:229]     Train net output #0: loss = 0.0401988 (* 1 = 0.0401988 loss)
 961 | I0806 09:45:27.502670 11748 solver.cpp:486] Iteration 1000, lr = 0.04
 962 | I0806 09:45:28.481725 11748 solver.cpp:214] Iteration 1100, loss = 0.00360373
 963 | I0806 09:45:28.481725 11748 solver.cpp:229]     Train net output #0: loss = 0.00360381 (* 1 = 0.00360381 loss)
 964 | I0806 09:45:28.482725 11748 solver.cpp:486] Iteration 1100, lr = 0.04
 965 | I0806 09:45:29.468781 11748 solver.cpp:214] Iteration 1200, loss = 0.115456
 966 | I0806 09:45:29.471781 11748 solver.cpp:229]     Train net output #0: loss = 0.115456 (* 1 = 0.115456 loss)
 967 | I0806 09:45:29.478782 11748 solver.cpp:486] Iteration 1200, lr = 0.04
 968 | I0806 09:45:30.453838 11748 solver.cpp:214] Iteration 1300, loss = 0.0086775
 969 | I0806 09:45:30.454838 11748 solver.cpp:229]     Train net output #0: loss = 0.0086776 (* 1 = 0.0086776 loss)
 970 | I0806 09:45:30.454838 11748 solver.cpp:486] Iteration 1300, lr = 0.04
 971 | I0806 09:45:31.430893 11748 solver.cpp:214] Iteration 1400, loss = 0.00986404
 972 | I0806 09:45:31.430893 11748 solver.cpp:229]     Train net output #0: loss = 0.00986412 (* 1 = 0.00986412 loss)
 973 | I0806 09:45:31.431893 11748 solver.cpp:486] Iteration 1400, lr = 0.04
 974 | I0806 09:45:32.408949 11748 solver.cpp:214] Iteration 1500, loss = 0.0921006
 975 | I0806 09:45:32.409950 11748 solver.cpp:229]     Train net output #0: loss = 0.0921007 (* 1 = 0.0921007 loss)
 976 | I0806 09:45:32.409950 11748 solver.cpp:486] Iteration 1500, lr = 0.04
 977 | I0806 09:45:33.378005 11748 solver.cpp:214] Iteration 1600, loss = 0.111908
 978 | I0806 09:45:33.379005 11748 solver.cpp:229]     Train net output #0: loss = 0.111908 (* 1 = 0.111908 loss)
 979 | I0806 09:45:33.381006 11748 solver.cpp:486] Iteration 1600, lr = 0.04
 980 | I0806 09:45:34.351060 11748 solver.cpp:214] Iteration 1700, loss = 0.0105853
 981 | I0806 09:45:34.352061 11748 solver.cpp:229]     Train net output #0: loss = 0.0105854 (* 1 = 0.0105854 loss)
 982 | I0806 09:45:34.352061 11748 solver.cpp:486] Iteration 1700, lr = 0.04
 983 | I0806 09:45:35.321116 11748 solver.cpp:214] Iteration 1800, loss = 0.0114328
 984 | I0806 09:45:35.322116 11748 solver.cpp:229]     Train net output #0: loss = 0.0114329 (* 1 = 0.0114329 loss)
 985 | I0806 09:45:35.322116 11748 solver.cpp:486] Iteration 1800, lr = 0.04
 986 | I0806 09:45:36.299172 11748 solver.cpp:214] Iteration 1900, loss = 0.152364
 987 | I0806 09:45:36.300173 11748 solver.cpp:229]     Train net output #0: loss = 0.152365 (* 1 = 0.152365 loss)
 988 | I0806 09:45:36.300173 11748 solver.cpp:486] Iteration 1900, lr = 0.04
 989 | I0806 09:45:37.268228 11748 solver.cpp:294] Iteration 2000, Testing net (#0)
 990 | I0806 09:45:37.825259 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9906
 991 | I0806 09:45:37.826259 11748 solver.cpp:343]     Test net output #1: loss = 0.0314774 (* 1 = 0.0314774 loss)
 992 | I0806 09:45:37.832260 11748 solver.cpp:214] Iteration 2000, loss = 0.00243739
 993 | I0806 09:45:37.833261 11748 solver.cpp:229]     Train net output #0: loss = 0.00243742 (* 1 = 0.00243742 loss)
 994 | I0806 09:45:37.833261 11748 solver.cpp:486] Iteration 2000, lr = 0.04
 995 | I0806 09:45:38.817317 11748 solver.cpp:214] Iteration 2100, loss = 0.0282853
 996 | I0806 09:45:38.818316 11748 solver.cpp:229]     Train net output #0: loss = 0.0282853 (* 1 = 0.0282853 loss)
 997 | I0806 09:45:38.819316 11748 solver.cpp:486] Iteration 2100, lr = 0.04
 998 | I0806 09:45:39.798372 11748 solver.cpp:214] Iteration 2200, loss = 0.00365397
 999 | I0806 09:45:39.798372 11748 solver.cpp:229]     Train net output #0: loss = 0.003654 (* 1 = 0.003654 loss)
1000 | I0806 09:45:39.799372 11748 solver.cpp:486] Iteration 2200, lr = 0.04
1001 | I0806 09:45:40.769428 11748 solver.cpp:214] Iteration 2300, loss = 0.0638009
1002 | I0806 09:45:40.770428 11748 solver.cpp:229]     Train net output #0: loss = 0.0638009 (* 1 = 0.0638009 loss)
1003 | I0806 09:45:40.770428 11748 solver.cpp:486] Iteration 2300, lr = 0.04
1004 | I0806 09:45:41.755484 11748 solver.cpp:214] Iteration 2400, loss = 0.00383741
1005 | I0806 09:45:41.756484 11748 solver.cpp:229]     Train net output #0: loss = 0.00383742 (* 1 = 0.00383742 loss)
1006 | I0806 09:45:41.756484 11748 solver.cpp:486] Iteration 2400, lr = 0.04
1007 | I0806 09:45:42.744540 11748 solver.cpp:214] Iteration 2500, loss = 0.0213382
1008 | I0806 09:45:42.745542 11748 solver.cpp:229]     Train net output #0: loss = 0.0213382 (* 1 = 0.0213382 loss)
1009 | I0806 09:45:42.745542 11748 solver.cpp:486] Iteration 2500, lr = 0.04
1010 | I0806 09:45:43.720597 11748 solver.cpp:214] Iteration 2600, loss = 0.061779
1011 | I0806 09:45:43.721596 11748 solver.cpp:229]     Train net output #0: loss = 0.061779 (* 1 = 0.061779 loss)
1012 | I0806 09:45:43.722596 11748 solver.cpp:486] Iteration 2600, lr = 0.04
1013 | I0806 09:45:44.696652 11748 solver.cpp:214] Iteration 2700, loss = 0.170432
1014 | I0806 09:45:44.696652 11748 solver.cpp:229]     Train net output #0: loss = 0.170432 (* 1 = 0.170432 loss)
1015 | I0806 09:45:44.697652 11748 solver.cpp:486] Iteration 2700, lr = 0.04
1016 | I0806 09:45:45.687710 11748 solver.cpp:214] Iteration 2800, loss = 8.17279e-005
1017 | I0806 09:45:45.688709 11748 solver.cpp:229]     Train net output #0: loss = 8.17024e-005 (* 1 = 8.17024e-005 loss)
1018 | I0806 09:45:45.688709 11748 solver.cpp:486] Iteration 2800, lr = 0.04
1019 | I0806 09:45:46.695766 11748 solver.cpp:214] Iteration 2900, loss = 0.00378953
1020 | I0806 09:45:46.696768 11748 solver.cpp:229]     Train net output #0: loss = 0.00378952 (* 1 = 0.00378952 loss)
1021 | I0806 09:45:46.696768 11748 solver.cpp:486] Iteration 2900, lr = 0.04
1022 | I0806 09:45:47.668823 11748 solver.cpp:294] Iteration 3000, Testing net (#0)
1023 | I0806 09:45:48.232854 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9903
1024 | I0806 09:45:48.233855 11748 solver.cpp:343]     Test net output #1: loss = 0.0304012 (* 1 = 0.0304012 loss)
1025 | I0806 09:45:48.239856 11748 solver.cpp:214] Iteration 3000, loss = 0.00582517
1026 | I0806 09:45:48.240855 11748 solver.cpp:229]     Train net output #0: loss = 0.00582515 (* 1 = 0.00582515 loss)
1027 | I0806 09:45:48.240855 11748 solver.cpp:486] Iteration 3000, lr = 0.04
1028 | I0806 09:45:49.222911 11748 solver.cpp:214] Iteration 3100, loss = 0.00272511
1029 | I0806 09:45:49.223912 11748 solver.cpp:229]     Train net output #0: loss = 0.0027251 (* 1 = 0.0027251 loss)
1030 | I0806 09:45:49.223912 11748 solver.cpp:486] Iteration 3100, lr = 0.04
1031 | I0806 09:45:50.189966 11748 solver.cpp:214] Iteration 3200, loss = 0.00256651
1032 | I0806 09:45:50.189966 11748 solver.cpp:229]     Train net output #0: loss = 0.00256648 (* 1 = 0.00256648 loss)
1033 | I0806 09:45:50.190966 11748 solver.cpp:486] Iteration 3200, lr = 0.04
1034 | I0806 09:45:51.165022 11748 solver.cpp:214] Iteration 3300, loss = 0.0640772
1035 | I0806 09:45:51.166023 11748 solver.cpp:229]     Train net output #0: loss = 0.0640772 (* 1 = 0.0640772 loss)
1036 | I0806 09:45:51.166023 11748 solver.cpp:486] Iteration 3300, lr = 0.04
1037 | I0806 09:45:52.132077 11748 solver.cpp:214] Iteration 3400, loss = 0.00565631
1038 | I0806 09:45:52.133077 11748 solver.cpp:229]     Train net output #0: loss = 0.00565632 (* 1 = 0.00565632 loss)
1039 | I0806 09:45:52.133077 11748 solver.cpp:486] Iteration 3400, lr = 0.04
1040 | I0806 09:45:53.087132 11748 solver.cpp:214] Iteration 3500, loss = 0.00180005
1041 | I0806 09:45:53.088132 11748 solver.cpp:229]     Train net output #0: loss = 0.00180005 (* 1 = 0.00180005 loss)
1042 | I0806 09:45:53.088132 11748 solver.cpp:486] Iteration 3500, lr = 0.04
1043 | I0806 09:45:54.066189 11748 solver.cpp:214] Iteration 3600, loss = 0.0399373
1044 | I0806 09:45:54.066189 11748 solver.cpp:229]     Train net output #0: loss = 0.0399373 (* 1 = 0.0399373 loss)
1045 | I0806 09:45:54.067188 11748 solver.cpp:486] Iteration 3600, lr = 0.04
1046 | I0806 09:45:55.081246 11748 solver.cpp:214] Iteration 3700, loss = 0.0252049
1047 | I0806 09:45:55.082247 11748 solver.cpp:229]     Train net output #0: loss = 0.0252049 (* 1 = 0.0252049 loss)
1048 | I0806 09:45:55.083246 11748 solver.cpp:486] Iteration 3700, lr = 0.04
1049 | I0806 09:45:56.064302 11748 solver.cpp:214] Iteration 3800, loss = 0.027904
1050 | I0806 09:45:56.065302 11748 solver.cpp:229]     Train net output #0: loss = 0.0279041 (* 1 = 0.0279041 loss)
1051 | I0806 09:45:56.065302 11748 solver.cpp:486] Iteration 3800, lr = 0.04
1052 | I0806 09:45:57.056360 11748 solver.cpp:214] Iteration 3900, loss = 0.00190786
1053 | I0806 09:45:57.057359 11748 solver.cpp:229]     Train net output #0: loss = 0.00190791 (* 1 = 0.00190791 loss)
1054 | I0806 09:45:57.057359 11748 solver.cpp:486] Iteration 3900, lr = 0.04
1055 | I0806 09:45:58.024415 11748 solver.cpp:294] Iteration 4000, Testing net (#0)
1056 | I0806 09:45:58.572446 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9929
1057 | I0806 09:45:58.573446 11748 solver.cpp:343]     Test net output #1: loss = 0.023563 (* 1 = 0.023563 loss)
1058 | I0806 09:45:58.579447 11748 solver.cpp:214] Iteration 4000, loss = 0.00774767
1059 | I0806 09:45:58.580446 11748 solver.cpp:229]     Train net output #0: loss = 0.00774772 (* 1 = 0.00774772 loss)
1060 | I0806 09:45:58.580446 11748 solver.cpp:486] Iteration 4000, lr = 0.04
1061 | I0806 09:45:59.564503 11748 solver.cpp:214] Iteration 4100, loss = 0.0199576
1062 | I0806 09:45:59.565503 11748 solver.cpp:229]     Train net output #0: loss = 0.0199576 (* 1 = 0.0199576 loss)
1063 | I0806 09:45:59.566504 11748 solver.cpp:486] Iteration 4100, lr = 0.04
1064 | I0806 09:46:00.550559 11748 solver.cpp:214] Iteration 4200, loss = 0.00111384
1065 | I0806 09:46:00.550559 11748 solver.cpp:229]     Train net output #0: loss = 0.00111388 (* 1 = 0.00111388 loss)
1066 | I0806 09:46:00.551559 11748 solver.cpp:486] Iteration 4200, lr = 0.04
1067 | I0806 09:46:01.541616 11748 solver.cpp:214] Iteration 4300, loss = 0.0734202
1068 | I0806 09:46:01.541616 11748 solver.cpp:229]     Train net output #0: loss = 0.0734203 (* 1 = 0.0734203 loss)
1069 | I0806 09:46:01.542616 11748 solver.cpp:486] Iteration 4300, lr = 0.04
1070 | I0806 09:46:02.519672 11748 solver.cpp:214] Iteration 4400, loss = 0.00497059
1071 | I0806 09:46:02.520673 11748 solver.cpp:229]     Train net output #0: loss = 0.00497066 (* 1 = 0.00497066 loss)
1072 | I0806 09:46:02.521672 11748 solver.cpp:486] Iteration 4400, lr = 0.04
1073 | I0806 09:46:03.502728 11748 solver.cpp:214] Iteration 4500, loss = 0.00865547
1074 | I0806 09:46:03.502728 11748 solver.cpp:229]     Train net output #0: loss = 0.00865555 (* 1 = 0.00865555 loss)
1075 | I0806 09:46:03.503728 11748 solver.cpp:486] Iteration 4500, lr = 0.04
1076 | I0806 09:46:04.480784 11748 solver.cpp:214] Iteration 4600, loss = 0.0100292
1077 | I0806 09:46:04.481784 11748 solver.cpp:229]     Train net output #0: loss = 0.0100293 (* 1 = 0.0100293 loss)
1078 | I0806 09:46:04.481784 11748 solver.cpp:486] Iteration 4600, lr = 0.04
1079 | I0806 09:46:05.455840 11748 solver.cpp:214] Iteration 4700, loss = 0.00231772
1080 | I0806 09:46:05.456840 11748 solver.cpp:229]     Train net output #0: loss = 0.00231777 (* 1 = 0.00231777 loss)
1081 | I0806 09:46:05.456840 11748 solver.cpp:486] Iteration 4700, lr = 0.04
1082 | I0806 09:46:06.430896 11748 solver.cpp:214] Iteration 4800, loss = 0.00851949
1083 | I0806 09:46:06.431895 11748 solver.cpp:229]     Train net output #0: loss = 0.00851954 (* 1 = 0.00851954 loss)
1084 | I0806 09:46:06.432895 11748 solver.cpp:486] Iteration 4800, lr = 0.04
1085 | I0806 09:46:07.403951 11748 solver.cpp:214] Iteration 4900, loss = 0.00360017
1086 | I0806 09:46:07.404952 11748 solver.cpp:229]     Train net output #0: loss = 0.00360022 (* 1 = 0.00360022 loss)
1087 | I0806 09:46:07.404952 11748 solver.cpp:486] Iteration 4900, lr = 0.04
1088 | I0806 09:46:08.380007 11748 solver.cpp:361] Snapshotting to lenet_iter_5000.caffemodel
1089 | I0806 09:46:08.393008 11748 solver.cpp:369] Snapshotting solver state to lenet_iter_5000.solverstate
1090 | I0806 09:46:08.400008 11748 solver.cpp:294] Iteration 5000, Testing net (#0)
1091 | I0806 09:46:08.951040 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9927
1092 | I0806 09:46:08.951040 11748 solver.cpp:343]     Test net output #1: loss = 0.0290423 (* 1 = 0.0290423 loss)
1093 | I0806 09:46:08.958040 11748 solver.cpp:214] Iteration 5000, loss = 0.0136682
1094 | I0806 09:46:08.958040 11748 solver.cpp:229]     Train net output #0: loss = 0.0136682 (* 1 = 0.0136682 loss)
1095 | I0806 09:46:08.959040 11748 solver.cpp:486] Iteration 5000, lr = 0.04
1096 | I0806 09:46:09.932096 11748 solver.cpp:214] Iteration 5100, loss = 0.0529536
1097 | I0806 09:46:09.932096 11748 solver.cpp:229]     Train net output #0: loss = 0.0529536 (* 1 = 0.0529536 loss)
1098 | I0806 09:46:09.933096 11748 solver.cpp:486] Iteration 5100, lr = 0.04
1099 | I0806 09:46:10.906152 11748 solver.cpp:214] Iteration 5200, loss = 0.0437232
1100 | I0806 09:46:10.907151 11748 solver.cpp:229]     Train net output #0: loss = 0.0437233 (* 1 = 0.0437233 loss)
1101 | I0806 09:46:10.907151 11748 solver.cpp:486] Iteration 5200, lr = 0.04
1102 | I0806 09:46:11.881207 11748 solver.cpp:214] Iteration 5300, loss = 0.00236913
1103 | I0806 09:46:11.882207 11748 solver.cpp:229]     Train net output #0: loss = 0.00236919 (* 1 = 0.00236919 loss)
1104 | I0806 09:46:11.882207 11748 solver.cpp:486] Iteration 5300, lr = 0.04
1105 | I0806 09:46:12.897265 11748 solver.cpp:214] Iteration 5400, loss = 0.00589903
1106 | I0806 09:46:12.898265 11748 solver.cpp:229]     Train net output #0: loss = 0.00589909 (* 1 = 0.00589909 loss)
1107 | I0806 09:46:12.899266 11748 solver.cpp:486] Iteration 5400, lr = 0.04
1108 | I0806 09:46:13.903323 11748 solver.cpp:214] Iteration 5500, loss = 0.00029134
1109 | I0806 09:46:13.903323 11748 solver.cpp:229]     Train net output #0: loss = 0.000291403 (* 1 = 0.000291403 loss)
1110 | I0806 09:46:13.904323 11748 solver.cpp:486] Iteration 5500, lr = 0.04
1111 | I0806 09:46:14.897380 11748 solver.cpp:214] Iteration 5600, loss = 3.36899e-005
1112 | I0806 09:46:14.898380 11748 solver.cpp:229]     Train net output #0: loss = 3.37618e-005 (* 1 = 3.37618e-005 loss)
1113 | I0806 09:46:14.899380 11748 solver.cpp:486] Iteration 5600, lr = 0.04
1114 | I0806 09:46:15.896437 11748 solver.cpp:214] Iteration 5700, loss = 0.00054144
1115 | I0806 09:46:15.896437 11748 solver.cpp:229]     Train net output #0: loss = 0.000541514 (* 1 = 0.000541514 loss)
1116 | I0806 09:46:15.897438 11748 solver.cpp:486] Iteration 5700, lr = 0.04
1117 | I0806 09:46:16.900495 11748 solver.cpp:214] Iteration 5800, loss = 0.00385042
1118 | I0806 09:46:16.901494 11748 solver.cpp:229]     Train net output #0: loss = 0.0038505 (* 1 = 0.0038505 loss)
1119 | I0806 09:46:16.901494 11748 solver.cpp:486] Iteration 5800, lr = 0.04
1120 | I0806 09:46:17.901551 11748 solver.cpp:214] Iteration 5900, loss = 0.0142767
1121 | I0806 09:46:17.902551 11748 solver.cpp:229]     Train net output #0: loss = 0.0142767 (* 1 = 0.0142767 loss)
1122 | I0806 09:46:17.902551 11748 solver.cpp:486] Iteration 5900, lr = 0.04
1123 | I0806 09:46:18.895608 11748 solver.cpp:294] Iteration 6000, Testing net (#0)
1124 | I0806 09:46:19.465641 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9942
1125 | I0806 09:46:19.466641 11748 solver.cpp:343]     Test net output #1: loss = 0.0240181 (* 1 = 0.0240181 loss)
1126 | I0806 09:46:19.473641 11748 solver.cpp:214] Iteration 6000, loss = 0.00354051
1127 | I0806 09:46:19.473641 11748 solver.cpp:229]     Train net output #0: loss = 0.00354058 (* 1 = 0.00354058 loss)
1128 | I0806 09:46:19.474642 11748 solver.cpp:486] Iteration 6000, lr = 0.00571428
1129 | I0806 09:46:20.515702 11748 solver.cpp:214] Iteration 6100, loss = 0.0155916
1130 | I0806 09:46:20.516701 11748 solver.cpp:229]     Train net output #0: loss = 0.0155917 (* 1 = 0.0155917 loss)
1131 | I0806 09:46:20.516701 11748 solver.cpp:486] Iteration 6100, lr = 0.00571428
1132 | I0806 09:46:21.540760 11748 solver.cpp:214] Iteration 6200, loss = 0.00375547
1133 | I0806 09:46:21.541760 11748 solver.cpp:229]     Train net output #0: loss = 0.00375554 (* 1 = 0.00375554 loss)
1134 | I0806 09:46:21.541760 11748 solver.cpp:486] Iteration 6200, lr = 0.00571428
1135 | I0806 09:46:22.570818 11748 solver.cpp:214] Iteration 6300, loss = 0.000583074
1136 | I0806 09:46:22.571818 11748 solver.cpp:229]     Train net output #0: loss = 0.00058313 (* 1 = 0.00058313 loss)
1137 | I0806 09:46:22.571818 11748 solver.cpp:486] Iteration 6300, lr = 0.00571428
1138 | I0806 09:46:23.591877 11748 solver.cpp:214] Iteration 6400, loss = 0.00156673
1139 | I0806 09:46:23.592877 11748 solver.cpp:229]     Train net output #0: loss = 0.0015668 (* 1 = 0.0015668 loss)
1140 | I0806 09:46:23.593878 11748 solver.cpp:486] Iteration 6400, lr = 0.00571428
1141 | I0806 09:46:24.623936 11748 solver.cpp:214] Iteration 6500, loss = 0.0205161
1142 | I0806 09:46:24.623936 11748 solver.cpp:229]     Train net output #0: loss = 0.0205162 (* 1 = 0.0205162 loss)
1143 | I0806 09:46:24.624936 11748 solver.cpp:486] Iteration 6500, lr = 0.00571428
1144 | I0806 09:46:25.647994 11748 solver.cpp:214] Iteration 6600, loss = 0.029536
1145 | I0806 09:46:25.648994 11748 solver.cpp:229]     Train net output #0: loss = 0.0295361 (* 1 = 0.0295361 loss)
1146 | I0806 09:46:25.649996 11748 solver.cpp:486] Iteration 6600, lr = 0.00571428
1147 | I0806 09:46:26.673053 11748 solver.cpp:214] Iteration 6700, loss = 0.0291454
1148 | I0806 09:46:26.673053 11748 solver.cpp:229]     Train net output #0: loss = 0.0291455 (* 1 = 0.0291455 loss)
1149 | I0806 09:46:26.674053 11748 solver.cpp:486] Iteration 6700, lr = 0.00571428
1150 | I0806 09:46:27.720113 11748 solver.cpp:214] Iteration 6800, loss = 0.00476583
1151 | I0806 09:46:27.720113 11748 solver.cpp:229]     Train net output #0: loss = 0.00476589 (* 1 = 0.00476589 loss)
1152 | I0806 09:46:27.721113 11748 solver.cpp:486] Iteration 6800, lr = 0.00571428
1153 | I0806 09:46:28.755172 11748 solver.cpp:214] Iteration 6900, loss = 0.00049654
1154 | I0806 09:46:28.755172 11748 solver.cpp:229]     Train net output #0: loss = 0.000496603 (* 1 = 0.000496603 loss)
1155 | I0806 09:46:28.756172 11748 solver.cpp:486] Iteration 6900, lr = 0.00571428
1156 | I0806 09:46:29.788231 11748 solver.cpp:294] Iteration 7000, Testing net (#0)
1157 | I0806 09:46:30.361264 11748 solver.cpp:343]     Test net output #0: accuracy = 0.995
1158 | I0806 09:46:30.362264 11748 solver.cpp:343]     Test net output #1: loss = 0.0197906 (* 1 = 0.0197906 loss)
1159 | I0806 09:46:30.368264 11748 solver.cpp:214] Iteration 7000, loss = 0.00150617
1160 | I0806 09:46:30.369264 11748 solver.cpp:229]     Train net output #0: loss = 0.00150623 (* 1 = 0.00150623 loss)
1161 | I0806 09:46:30.369264 11748 solver.cpp:486] Iteration 7000, lr = 0.00571428
1162 | I0806 09:46:31.425325 11748 solver.cpp:214] Iteration 7100, loss = 0.00816915
1163 | I0806 09:46:31.426326 11748 solver.cpp:229]     Train net output #0: loss = 0.00816921 (* 1 = 0.00816921 loss)
1164 | I0806 09:46:31.426326 11748 solver.cpp:486] Iteration 7100, lr = 0.00571428
1165 | I0806 09:46:32.473386 11748 solver.cpp:214] Iteration 7200, loss = 0.000406234
1166 | I0806 09:46:32.474385 11748 solver.cpp:229]     Train net output #0: loss = 0.000406295 (* 1 = 0.000406295 loss)
1167 | I0806 09:46:32.474385 11748 solver.cpp:486] Iteration 7200, lr = 0.00571428
1168 | I0806 09:46:33.509444 11748 solver.cpp:214] Iteration 7300, loss = 0.0310881
1169 | I0806 09:46:33.509444 11748 solver.cpp:229]     Train net output #0: loss = 0.0310881 (* 1 = 0.0310881 loss)
1170 | I0806 09:46:33.510444 11748 solver.cpp:486] Iteration 7300, lr = 0.00571428
1171 | I0806 09:46:34.544503 11748 solver.cpp:214] Iteration 7400, loss = 0.0430276
1172 | I0806 09:46:34.544503 11748 solver.cpp:229]     Train net output #0: loss = 0.0430277 (* 1 = 0.0430277 loss)
1173 | I0806 09:46:34.545503 11748 solver.cpp:486] Iteration 7400, lr = 0.00571428
1174 | I0806 09:46:35.585563 11748 solver.cpp:214] Iteration 7500, loss = 0.00738295
1175 | I0806 09:46:35.586563 11748 solver.cpp:229]     Train net output #0: loss = 0.007383 (* 1 = 0.007383 loss)
1176 | I0806 09:46:35.586563 11748 solver.cpp:486] Iteration 7500, lr = 0.00571428
1177 | I0806 09:46:36.647624 11748 solver.cpp:214] Iteration 7600, loss = 0.042879
1178 | I0806 09:46:36.648624 11748 solver.cpp:229]     Train net output #0: loss = 0.0428791 (* 1 = 0.0428791 loss)
1179 | I0806 09:46:36.648624 11748 solver.cpp:486] Iteration 7600, lr = 0.00571428
1180 | I0806 09:46:37.710685 11748 solver.cpp:214] Iteration 7700, loss = 0.0216624
1181 | I0806 09:46:37.710685 11748 solver.cpp:229]     Train net output #0: loss = 0.0216624 (* 1 = 0.0216624 loss)
1182 | I0806 09:46:37.711684 11748 solver.cpp:486] Iteration 7700, lr = 0.00571428
1183 | I0806 09:46:38.766746 11748 solver.cpp:214] Iteration 7800, loss = 0.000176566
1184 | I0806 09:46:38.767745 11748 solver.cpp:229]     Train net output #0: loss = 0.000176614 (* 1 = 0.000176614 loss)
1185 | I0806 09:46:38.768745 11748 solver.cpp:486] Iteration 7800, lr = 0.00571428
1186 | I0806 09:46:39.812805 11748 solver.cpp:214] Iteration 7900, loss = 0.00075841
1187 | I0806 09:46:39.813805 11748 solver.cpp:229]     Train net output #0: loss = 0.00075846 (* 1 = 0.00075846 loss)
1188 | I0806 09:46:39.813805 11748 solver.cpp:486] Iteration 7900, lr = 0.00571428
1189 | I0806 09:46:40.841863 11748 solver.cpp:294] Iteration 8000, Testing net (#0)
1190 | I0806 09:46:41.418896 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9954
1191 | I0806 09:46:41.419898 11748 solver.cpp:343]     Test net output #1: loss = 0.0195827 (* 1 = 0.0195827 loss)
1192 | I0806 09:46:41.425897 11748 solver.cpp:214] Iteration 8000, loss = 0.000233271
1193 | I0806 09:46:41.425897 11748 solver.cpp:229]     Train net output #0: loss = 0.000233324 (* 1 = 0.000233324 loss)
1194 | I0806 09:46:41.426898 11748 solver.cpp:486] Iteration 8000, lr = 0.00571428
1195 | I0806 09:46:42.468957 11748 solver.cpp:214] Iteration 8100, loss = 0.000942778
1196 | I0806 09:46:42.468957 11748 solver.cpp:229]     Train net output #0: loss = 0.00094284 (* 1 = 0.00094284 loss)
1197 | I0806 09:46:42.469957 11748 solver.cpp:486] Iteration 8100, lr = 0.00571428
1198 | I0806 09:46:43.502017 11748 solver.cpp:214] Iteration 8200, loss = 0.00384913
1199 | I0806 09:46:43.503016 11748 solver.cpp:229]     Train net output #0: loss = 0.00384918 (* 1 = 0.00384918 loss)
1200 | I0806 09:46:43.503016 11748 solver.cpp:486] Iteration 8200, lr = 0.00571428
1201 | I0806 09:46:44.534075 11748 solver.cpp:214] Iteration 8300, loss = 0.00351136
1202 | I0806 09:46:44.535075 11748 solver.cpp:229]     Train net output #0: loss = 0.00351142 (* 1 = 0.00351142 loss)
1203 | I0806 09:46:44.535075 11748 solver.cpp:486] Iteration 8300, lr = 0.00571428
1204 | I0806 09:46:45.561133 11748 solver.cpp:214] Iteration 8400, loss = 0.00693994
1205 | I0806 09:46:45.562134 11748 solver.cpp:229]     Train net output #0: loss = 0.00694 (* 1 = 0.00694 loss)
1206 | I0806 09:46:45.562134 11748 solver.cpp:486] Iteration 8400, lr = 0.00571428
1207 | I0806 09:46:46.597193 11748 solver.cpp:214] Iteration 8500, loss = 0.00120612
1208 | I0806 09:46:46.598193 11748 solver.cpp:229]     Train net output #0: loss = 0.00120618 (* 1 = 0.00120618 loss)
1209 | I0806 09:46:46.599194 11748 solver.cpp:486] Iteration 8500, lr = 0.00571428
1210 | I0806 09:46:47.630252 11748 solver.cpp:214] Iteration 8600, loss = 8.52296e-005
1211 | I0806 09:46:47.631253 11748 solver.cpp:229]     Train net output #0: loss = 8.52914e-005 (* 1 = 8.52914e-005 loss)
1212 | I0806 09:46:47.631253 11748 solver.cpp:486] Iteration 8600, lr = 0.00571428
1213 | I0806 09:46:48.662312 11748 solver.cpp:214] Iteration 8700, loss = 0.000670265
1214 | I0806 09:46:48.662312 11748 solver.cpp:229]     Train net output #0: loss = 0.000670326 (* 1 = 0.000670326 loss)
1215 | I0806 09:46:48.663311 11748 solver.cpp:486] Iteration 8700, lr = 0.00571428
1216 | I0806 09:46:49.693370 11748 solver.cpp:214] Iteration 8800, loss = 0.000801031
1217 | I0806 09:46:49.693370 11748 solver.cpp:229]     Train net output #0: loss = 0.000801087 (* 1 = 0.000801087 loss)
1218 | I0806 09:46:49.694370 11748 solver.cpp:486] Iteration 8800, lr = 0.00571428
1219 | I0806 09:46:50.722429 11748 solver.cpp:214] Iteration 8900, loss = 3.64929e-005
1220 | I0806 09:46:50.723429 11748 solver.cpp:229]     Train net output #0: loss = 3.65497e-005 (* 1 = 3.65497e-005 loss)
1221 | I0806 09:46:50.723429 11748 solver.cpp:486] Iteration 8900, lr = 0.00571428
1222 | I0806 09:46:51.749487 11748 solver.cpp:294] Iteration 9000, Testing net (#0)
1223 | I0806 09:46:52.327520 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9946
1224 | I0806 09:46:52.328521 11748 solver.cpp:343]     Test net output #1: loss = 0.0210733 (* 1 = 0.0210733 loss)
1225 | I0806 09:46:52.335521 11748 solver.cpp:214] Iteration 9000, loss = 0.00595421
1226 | I0806 09:46:52.335521 11748 solver.cpp:229]     Train net output #0: loss = 0.00595427 (* 1 = 0.00595427 loss)
1227 | I0806 09:46:52.336521 11748 solver.cpp:486] Iteration 9000, lr = 0.00571428
1228 | I0806 09:46:53.362581 11748 solver.cpp:214] Iteration 9100, loss = 0.00145497
1229 | I0806 09:46:53.363580 11748 solver.cpp:229]     Train net output #0: loss = 0.00145502 (* 1 = 0.00145502 loss)
1230 | I0806 09:46:53.363580 11748 solver.cpp:486] Iteration 9100, lr = 0.00571428
1231 | I0806 09:46:54.402639 11748 solver.cpp:214] Iteration 9200, loss = 0.000898812
1232 | I0806 09:46:54.402639 11748 solver.cpp:229]     Train net output #0: loss = 0.000898867 (* 1 = 0.000898867 loss)
1233 | I0806 09:46:54.403640 11748 solver.cpp:486] Iteration 9200, lr = 0.00571428
1234 | I0806 09:46:55.451699 11748 solver.cpp:214] Iteration 9300, loss = 0.000267679
1235 | I0806 09:46:55.451699 11748 solver.cpp:229]     Train net output #0: loss = 0.000267737 (* 1 = 0.000267737 loss)
1236 | I0806 09:46:55.452699 11748 solver.cpp:486] Iteration 9300, lr = 0.00571428
1237 | I0806 09:46:56.487758 11748 solver.cpp:214] Iteration 9400, loss = 0.00857365
1238 | I0806 09:46:56.487758 11748 solver.cpp:229]     Train net output #0: loss = 0.00857371 (* 1 = 0.00857371 loss)
1239 | I0806 09:46:56.488759 11748 solver.cpp:486] Iteration 9400, lr = 0.00571428
1240 | I0806 09:46:57.531818 11748 solver.cpp:214] Iteration 9500, loss = 3.51604e-005
1241 | I0806 09:46:57.532819 11748 solver.cpp:229]     Train net output #0: loss = 3.5224e-005 (* 1 = 3.5224e-005 loss)
1242 | I0806 09:46:57.533818 11748 solver.cpp:486] Iteration 9500, lr = 0.00571428
1243 | I0806 09:46:58.569877 11748 solver.cpp:214] Iteration 9600, loss = 0.00436177
1244 | I0806 09:46:58.570878 11748 solver.cpp:229]     Train net output #0: loss = 0.00436184 (* 1 = 0.00436184 loss)
1245 | I0806 09:46:58.570878 11748 solver.cpp:486] Iteration 9600, lr = 0.00571428
1246 | I0806 09:46:59.599936 11748 solver.cpp:214] Iteration 9700, loss = 0.00386922
1247 | I0806 09:46:59.600936 11748 solver.cpp:229]     Train net output #0: loss = 0.00386929 (* 1 = 0.00386929 loss)
1248 | I0806 09:46:59.601936 11748 solver.cpp:486] Iteration 9700, lr = 0.00571428
1249 | I0806 09:47:00.625995 11748 solver.cpp:214] Iteration 9800, loss = 0.0061305
1250 | I0806 09:47:00.625995 11748 solver.cpp:229]     Train net output #0: loss = 0.00613057 (* 1 = 0.00613057 loss)
1251 | I0806 09:47:00.626996 11748 solver.cpp:486] Iteration 9800, lr = 0.00571428
1252 | I0806 09:47:01.652055 11748 solver.cpp:214] Iteration 9900, loss = 0.00653837
1253 | I0806 09:47:01.652055 11748 solver.cpp:229]     Train net output #0: loss = 0.00653844 (* 1 = 0.00653844 loss)
1254 | I0806 09:47:01.653054 11748 solver.cpp:486] Iteration 9900, lr = 0.00571428
1255 | I0806 09:47:02.689113 11748 solver.cpp:361] Snapshotting to lenet_iter_10000.caffemodel
1256 | I0806 09:47:02.701114 11748 solver.cpp:369] Snapshotting solver state to lenet_iter_10000.solverstate
1257 | I0806 09:47:02.709115 11748 solver.cpp:294] Iteration 10000, Testing net (#0)
1258 | I0806 09:47:03.297148 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9955
1259 | I0806 09:47:03.298148 11748 solver.cpp:343]     Test net output #1: loss = 0.018672 (* 1 = 0.018672 loss)
1260 | I0806 09:47:03.305148 11748 solver.cpp:214] Iteration 10000, loss = 4.95403e-005
1261 | I0806 09:47:03.305148 11748 solver.cpp:229]     Train net output #0: loss = 4.96036e-005 (* 1 = 4.96036e-005 loss)
1262 | I0806 09:47:03.306149 11748 solver.cpp:486] Iteration 10000, lr = 0.00571428
1263 | I0806 09:47:04.340208 11748 solver.cpp:214] Iteration 10100, loss = 0.00215863
1264 | I0806 09:47:04.341208 11748 solver.cpp:229]     Train net output #0: loss = 0.0021587 (* 1 = 0.0021587 loss)
1265 | I0806 09:47:04.342208 11748 solver.cpp:486] Iteration 10100, lr = 0.00571428
1266 | I0806 09:47:05.393268 11748 solver.cpp:214] Iteration 10200, loss = 0.00600045
1267 | I0806 09:47:05.393268 11748 solver.cpp:229]     Train net output #0: loss = 0.00600052 (* 1 = 0.00600052 loss)
1268 | I0806 09:47:05.394268 11748 solver.cpp:486] Iteration 10200, lr = 0.00571428
1269 | I0806 09:47:06.423327 11748 solver.cpp:214] Iteration 10300, loss = 4.12369e-006
1270 | I0806 09:47:06.423327 11748 solver.cpp:229]     Train net output #0: loss = 4.19105e-006 (* 1 = 4.19105e-006 loss)
1271 | I0806 09:47:06.424327 11748 solver.cpp:486] Iteration 10300, lr = 0.00571428
1272 | I0806 09:47:07.465386 11748 solver.cpp:214] Iteration 10400, loss = 0.00123365
1273 | I0806 09:47:07.466387 11748 solver.cpp:229]     Train net output #0: loss = 0.00123371 (* 1 = 0.00123371 loss)
1274 | I0806 09:47:07.466387 11748 solver.cpp:486] Iteration 10400, lr = 0.00571428
1275 | I0806 09:47:08.504446 11748 solver.cpp:214] Iteration 10500, loss = 0.0204815
1276 | I0806 09:47:08.505446 11748 solver.cpp:229]     Train net output #0: loss = 0.0204815 (* 1 = 0.0204815 loss)
1277 | I0806 09:47:08.505446 11748 solver.cpp:486] Iteration 10500, lr = 0.00571428
1278 | I0806 09:47:09.542505 11748 solver.cpp:214] Iteration 10600, loss = 0.00135396
1279 | I0806 09:47:09.543505 11748 solver.cpp:229]     Train net output #0: loss = 0.00135402 (* 1 = 0.00135402 loss)
1280 | I0806 09:47:09.543505 11748 solver.cpp:486] Iteration 10600, lr = 0.00571428
1281 | I0806 09:47:10.577564 11748 solver.cpp:214] Iteration 10700, loss = 0.000449026
1282 | I0806 09:47:10.578564 11748 solver.cpp:229]     Train net output #0: loss = 0.000449085 (* 1 = 0.000449085 loss)
1283 | I0806 09:47:10.578564 11748 solver.cpp:486] Iteration 10700, lr = 0.00571428
1284 | I0806 09:47:11.613625 11748 solver.cpp:214] Iteration 10800, loss = 0.00105877
1285 | I0806 09:47:11.614624 11748 solver.cpp:229]     Train net output #0: loss = 0.00105883 (* 1 = 0.00105883 loss)
1286 | I0806 09:47:11.614624 11748 solver.cpp:486] Iteration 10800, lr = 0.00571428
1287 | I0806 09:47:12.652683 11748 solver.cpp:214] Iteration 10900, loss = 0.00011861
1288 | I0806 09:47:12.653683 11748 solver.cpp:229]     Train net output #0: loss = 0.000118666 (* 1 = 0.000118666 loss)
1289 | I0806 09:47:12.654683 11748 solver.cpp:486] Iteration 10900, lr = 0.00571428
1290 | I0806 09:47:13.681742 11748 solver.cpp:294] Iteration 11000, Testing net (#0)
1291 | I0806 09:47:14.255775 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9952
1292 | I0806 09:47:14.256775 11748 solver.cpp:343]     Test net output #1: loss = 0.0186359 (* 1 = 0.0186359 loss)
1293 | I0806 09:47:14.262775 11748 solver.cpp:214] Iteration 11000, loss = 7.35691e-005
1294 | I0806 09:47:14.262775 11748 solver.cpp:229]     Train net output #0: loss = 7.36296e-005 (* 1 = 7.36296e-005 loss)
1295 | I0806 09:47:14.263775 11748 solver.cpp:486] Iteration 11000, lr = 0.00571428
1296 | I0806 09:47:15.291834 11748 solver.cpp:214] Iteration 11100, loss = 0.00257495
1297 | I0806 09:47:15.292834 11748 solver.cpp:229]     Train net output #0: loss = 0.00257502 (* 1 = 0.00257502 loss)
1298 | I0806 09:47:15.293834 11748 solver.cpp:486] Iteration 11100, lr = 0.00571428
1299 | I0806 09:47:16.341894 11748 solver.cpp:214] Iteration 11200, loss = 0.0151624
1300 | I0806 09:47:16.342895 11748 solver.cpp:229]     Train net output #0: loss = 0.0151625 (* 1 = 0.0151625 loss)
1301 | I0806 09:47:16.342895 11748 solver.cpp:486] Iteration 11200, lr = 0.00571428
1302 | I0806 09:47:17.396955 11748 solver.cpp:214] Iteration 11300, loss = 0.0133236
1303 | I0806 09:47:17.397954 11748 solver.cpp:229]     Train net output #0: loss = 0.0133236 (* 1 = 0.0133236 loss)
1304 | I0806 09:47:17.398954 11748 solver.cpp:486] Iteration 11300, lr = 0.00571428
1305 | I0806 09:47:18.447015 11748 solver.cpp:214] Iteration 11400, loss = 0.0005393
1306 | I0806 09:47:18.448014 11748 solver.cpp:229]     Train net output #0: loss = 0.000539364 (* 1 = 0.000539364 loss)
1307 | I0806 09:47:18.448014 11748 solver.cpp:486] Iteration 11400, lr = 0.00571428
1308 | I0806 09:47:19.476073 11748 solver.cpp:214] Iteration 11500, loss = 0.00112776
1309 | I0806 09:47:19.476073 11748 solver.cpp:229]     Train net output #0: loss = 0.00112783 (* 1 = 0.00112783 loss)
1310 | I0806 09:47:19.477073 11748 solver.cpp:486] Iteration 11500, lr = 0.00571428
1311 | I0806 09:47:20.511132 11748 solver.cpp:214] Iteration 11600, loss = 0.00162112
1312 | I0806 09:47:20.512132 11748 solver.cpp:229]     Train net output #0: loss = 0.00162118 (* 1 = 0.00162118 loss)
1313 | I0806 09:47:20.512132 11748 solver.cpp:486] Iteration 11600, lr = 0.00571428
1314 | I0806 09:47:21.542191 11748 solver.cpp:214] Iteration 11700, loss = 0.000946568
1315 | I0806 09:47:21.543191 11748 solver.cpp:229]     Train net output #0: loss = 0.000946629 (* 1 = 0.000946629 loss)
1316 | I0806 09:47:21.543191 11748 solver.cpp:486] Iteration 11700, lr = 0.00571428
1317 | I0806 09:47:22.580251 11748 solver.cpp:214] Iteration 11800, loss = 0.00118122
1318 | I0806 09:47:22.581251 11748 solver.cpp:229]     Train net output #0: loss = 0.00118128 (* 1 = 0.00118128 loss)
1319 | I0806 09:47:22.582252 11748 solver.cpp:486] Iteration 11800, lr = 0.00571428
1320 | I0806 09:47:23.636312 11748 solver.cpp:214] Iteration 11900, loss = 0.00110072
1321 | I0806 09:47:23.637311 11748 solver.cpp:229]     Train net output #0: loss = 0.00110078 (* 1 = 0.00110078 loss)
1322 | I0806 09:47:23.638311 11748 solver.cpp:486] Iteration 11900, lr = 0.00571428
1323 | I0806 09:47:24.663370 11748 solver.cpp:294] Iteration 12000, Testing net (#0)
1324 | I0806 09:47:25.249403 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9958
1325 | I0806 09:47:25.249403 11748 solver.cpp:343]     Test net output #1: loss = 0.0185153 (* 1 = 0.0185153 loss)
1326 | I0806 09:47:25.255404 11748 solver.cpp:214] Iteration 12000, loss = 0.00154361
1327 | I0806 09:47:25.256404 11748 solver.cpp:229]     Train net output #0: loss = 0.00154368 (* 1 = 0.00154368 loss)
1328 | I0806 09:47:25.256404 11748 solver.cpp:486] Iteration 12000, lr = 0.000816326
1329 | I0806 09:47:26.292464 11748 solver.cpp:214] Iteration 12100, loss = 0.0158387
1330 | I0806 09:47:26.293463 11748 solver.cpp:229]     Train net output #0: loss = 0.0158388 (* 1 = 0.0158388 loss)
1331 | I0806 09:47:26.293463 11748 solver.cpp:486] Iteration 12100, lr = 0.000816326
1332 | I0806 09:47:27.338523 11748 solver.cpp:214] Iteration 12200, loss = 0.000617221
1333 | I0806 09:47:27.338523 11748 solver.cpp:229]     Train net output #0: loss = 0.000617289 (* 1 = 0.000617289 loss)
1334 | I0806 09:47:27.339524 11748 solver.cpp:486] Iteration 12200, lr = 0.000816326
1335 | I0806 09:47:28.385583 11748 solver.cpp:214] Iteration 12300, loss = 0.0116959
1336 | I0806 09:47:28.386584 11748 solver.cpp:229]     Train net output #0: loss = 0.011696 (* 1 = 0.011696 loss)
1337 | I0806 09:47:28.386584 11748 solver.cpp:486] Iteration 12300, lr = 0.000816326
1338 | I0806 09:47:29.434643 11748 solver.cpp:214] Iteration 12400, loss = 0.0240795
1339 | I0806 09:47:29.435643 11748 solver.cpp:229]     Train net output #0: loss = 0.0240796 (* 1 = 0.0240796 loss)
1340 | I0806 09:47:29.435643 11748 solver.cpp:486] Iteration 12400, lr = 0.000816326
1341 | I0806 09:47:30.479703 11748 solver.cpp:214] Iteration 12500, loss = 0.00880103
1342 | I0806 09:47:30.479703 11748 solver.cpp:229]     Train net output #0: loss = 0.0088011 (* 1 = 0.0088011 loss)
1343 | I0806 09:47:30.480703 11748 solver.cpp:486] Iteration 12500, lr = 0.000816326
1344 | I0806 09:47:31.522763 11748 solver.cpp:214] Iteration 12600, loss = 0.0138287
1345 | I0806 09:47:31.523762 11748 solver.cpp:229]     Train net output #0: loss = 0.0138288 (* 1 = 0.0138288 loss)
1346 | I0806 09:47:31.524762 11748 solver.cpp:486] Iteration 12600, lr = 0.000816326
1347 | I0806 09:47:32.566823 11748 solver.cpp:214] Iteration 12700, loss = 0.000691713
1348 | I0806 09:47:32.567822 11748 solver.cpp:229]     Train net output #0: loss = 0.000691784 (* 1 = 0.000691784 loss)
1349 | I0806 09:47:32.567822 11748 solver.cpp:486] Iteration 12700, lr = 0.000816326
1350 | I0806 09:47:33.611882 11748 solver.cpp:214] Iteration 12800, loss = 0.000294084
1351 | I0806 09:47:33.611882 11748 solver.cpp:229]     Train net output #0: loss = 0.000294157 (* 1 = 0.000294157 loss)
1352 | I0806 09:47:33.612882 11748 solver.cpp:486] Iteration 12800, lr = 0.000816326
1353 | I0806 09:47:34.655941 11748 solver.cpp:214] Iteration 12900, loss = 0.00121791
1354 | I0806 09:47:34.656942 11748 solver.cpp:229]     Train net output #0: loss = 0.00121799 (* 1 = 0.00121799 loss)
1355 | I0806 09:47:34.656942 11748 solver.cpp:486] Iteration 12900, lr = 0.000816326
1356 | I0806 09:47:35.693001 11748 solver.cpp:294] Iteration 13000, Testing net (#0)
1357 | I0806 09:47:36.270035 11748 solver.cpp:343]     Test net output #0: accuracy = 0.995
1358 | I0806 09:47:36.271034 11748 solver.cpp:343]     Test net output #1: loss = 0.0213863 (* 1 = 0.0213863 loss)
1359 | I0806 09:47:36.277034 11748 solver.cpp:214] Iteration 13000, loss = 0.00027381
1360 | I0806 09:47:36.277034 11748 solver.cpp:229]     Train net output #0: loss = 0.000273889 (* 1 = 0.000273889 loss)
1361 | I0806 09:47:36.277034 11748 solver.cpp:486] Iteration 13000, lr = 0.000816326
1362 | I0806 09:47:37.319094 11748 solver.cpp:214] Iteration 13100, loss = 2.43156e-005
1363 | I0806 09:47:37.320094 11748 solver.cpp:229]     Train net output #0: loss = 2.43907e-005 (* 1 = 2.43907e-005 loss)
1364 | I0806 09:47:37.320094 11748 solver.cpp:486] Iteration 13100, lr = 0.000816326
1365 | I0806 09:47:38.358153 11748 solver.cpp:214] Iteration 13200, loss = 0.00137979
1366 | I0806 09:47:38.359153 11748 solver.cpp:229]     Train net output #0: loss = 0.00137987 (* 1 = 0.00137987 loss)
1367 | I0806 09:47:38.359153 11748 solver.cpp:486] Iteration 13200, lr = 0.000816326
1368 | I0806 09:47:39.402214 11748 solver.cpp:214] Iteration 13300, loss = 0.000111218
1369 | I0806 09:47:39.402214 11748 solver.cpp:229]     Train net output #0: loss = 0.000111291 (* 1 = 0.000111291 loss)
1370 | I0806 09:47:39.403213 11748 solver.cpp:486] Iteration 13300, lr = 0.000816326
1371 | I0806 09:47:40.449273 11748 solver.cpp:214] Iteration 13400, loss = 0.00097954
1372 | I0806 09:47:40.450273 11748 solver.cpp:229]     Train net output #0: loss = 0.000979614 (* 1 = 0.000979614 loss)
1373 | I0806 09:47:40.451273 11748 solver.cpp:486] Iteration 13400, lr = 0.000816326
1374 | I0806 09:47:41.498333 11748 solver.cpp:214] Iteration 13500, loss = 0.00309913
1375 | I0806 09:47:41.499333 11748 solver.cpp:229]     Train net output #0: loss = 0.0030992 (* 1 = 0.0030992 loss)
1376 | I0806 09:47:41.500334 11748 solver.cpp:486] Iteration 13500, lr = 0.000816326
1377 | I0806 09:47:42.548393 11748 solver.cpp:214] Iteration 13600, loss = 0.000776991
1378 | I0806 09:47:42.549393 11748 solver.cpp:229]     Train net output #0: loss = 0.00077706 (* 1 = 0.00077706 loss)
1379 | I0806 09:47:42.549393 11748 solver.cpp:486] Iteration 13600, lr = 0.000816326
1380 | I0806 09:47:43.596453 11748 solver.cpp:214] Iteration 13700, loss = 0.00112871
1381 | I0806 09:47:43.596453 11748 solver.cpp:229]     Train net output #0: loss = 0.00112879 (* 1 = 0.00112879 loss)
1382 | I0806 09:47:43.597453 11748 solver.cpp:486] Iteration 13700, lr = 0.000816326
1383 | I0806 09:47:44.646513 11748 solver.cpp:214] Iteration 13800, loss = 0.0127243
1384 | I0806 09:47:44.647513 11748 solver.cpp:229]     Train net output #0: loss = 0.0127243 (* 1 = 0.0127243 loss)
1385 | I0806 09:47:44.647513 11748 solver.cpp:486] Iteration 13800, lr = 0.000816326
1386 | I0806 09:47:45.705574 11748 solver.cpp:214] Iteration 13900, loss = 0.00115382
1387 | I0806 09:47:45.705574 11748 solver.cpp:229]     Train net output #0: loss = 0.00115388 (* 1 = 0.00115388 loss)
1388 | I0806 09:47:45.706574 11748 solver.cpp:486] Iteration 13900, lr = 0.000816326
1389 | I0806 09:47:46.750633 11748 solver.cpp:294] Iteration 14000, Testing net (#0)
1390 | I0806 09:47:47.342667 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9949
1391 | I0806 09:47:47.343667 11748 solver.cpp:343]     Test net output #1: loss = 0.0194077 (* 1 = 0.0194077 loss)
1392 | I0806 09:47:47.349668 11748 solver.cpp:214] Iteration 14000, loss = 0.000690686
1393 | I0806 09:47:47.349668 11748 solver.cpp:229]     Train net output #0: loss = 0.000690754 (* 1 = 0.000690754 loss)
1394 | I0806 09:47:47.350668 11748 solver.cpp:486] Iteration 14000, lr = 0.000816326
1395 | I0806 09:47:48.403728 11748 solver.cpp:214] Iteration 14100, loss = 0.010082
1396 | I0806 09:47:48.404728 11748 solver.cpp:229]     Train net output #0: loss = 0.0100821 (* 1 = 0.0100821 loss)
1397 | I0806 09:47:48.404728 11748 solver.cpp:486] Iteration 14100, lr = 0.000816326
1398 | I0806 09:47:49.456789 11748 solver.cpp:214] Iteration 14200, loss = 0.0159314
1399 | I0806 09:47:49.457788 11748 solver.cpp:229]     Train net output #0: loss = 0.0159315 (* 1 = 0.0159315 loss)
1400 | I0806 09:47:49.458788 11748 solver.cpp:486] Iteration 14200, lr = 0.000816326
1401 | I0806 09:47:50.519850 11748 solver.cpp:214] Iteration 14300, loss = 0.000589024
1402 | I0806 09:47:50.521849 11748 solver.cpp:229]     Train net output #0: loss = 0.000589085 (* 1 = 0.000589085 loss)
1403 | I0806 09:47:50.521849 11748 solver.cpp:486] Iteration 14300, lr = 0.000816326
1404 | I0806 09:47:51.582911 11748 solver.cpp:214] Iteration 14400, loss = 9.12001e-005
1405 | I0806 09:47:51.583910 11748 solver.cpp:229]     Train net output #0: loss = 9.1262e-005 (* 1 = 9.1262e-005 loss)
1406 | I0806 09:47:51.584910 11748 solver.cpp:486] Iteration 14400, lr = 0.000816326
1407 | I0806 09:47:52.641970 11748 solver.cpp:214] Iteration 14500, loss = 0.00137573
1408 | I0806 09:47:52.643970 11748 solver.cpp:229]     Train net output #0: loss = 0.00137579 (* 1 = 0.00137579 loss)
1409 | I0806 09:47:52.644970 11748 solver.cpp:486] Iteration 14500, lr = 0.000816326
1410 | I0806 09:47:53.703032 11748 solver.cpp:214] Iteration 14600, loss = 0.00100744
1411 | I0806 09:47:53.704031 11748 solver.cpp:229]     Train net output #0: loss = 0.00100749 (* 1 = 0.00100749 loss)
1412 | I0806 09:47:53.705031 11748 solver.cpp:486] Iteration 14600, lr = 0.000816326
1413 | I0806 09:47:54.756091 11748 solver.cpp:214] Iteration 14700, loss = 0.000341144
1414 | I0806 09:47:54.757091 11748 solver.cpp:229]     Train net output #0: loss = 0.000341197 (* 1 = 0.000341197 loss)
1415 | I0806 09:47:54.758091 11748 solver.cpp:486] Iteration 14700, lr = 0.000816326
1416 | I0806 09:47:55.813153 11748 solver.cpp:214] Iteration 14800, loss = 0.00391233
1417 | I0806 09:47:55.814152 11748 solver.cpp:229]     Train net output #0: loss = 0.00391239 (* 1 = 0.00391239 loss)
1418 | I0806 09:47:55.815152 11748 solver.cpp:486] Iteration 14800, lr = 0.000816326
1419 | I0806 09:47:56.871212 11748 solver.cpp:214] Iteration 14900, loss = 0.00247528
1420 | I0806 09:47:56.872212 11748 solver.cpp:229]     Train net output #0: loss = 0.00247533 (* 1 = 0.00247533 loss)
1421 | I0806 09:47:56.872212 11748 solver.cpp:486] Iteration 14900, lr = 0.000816326
1422 | I0806 09:47:57.931273 11748 solver.cpp:361] Snapshotting to lenet_iter_15000.caffemodel
1423 | I0806 09:47:57.943274 11748 solver.cpp:369] Snapshotting solver state to lenet_iter_15000.solverstate
1424 | I0806 09:47:57.956274 11748 solver.cpp:276] Iteration 15000, loss = 0.00506475
1425 | I0806 09:47:57.956274 11748 solver.cpp:294] Iteration 15000, Testing net (#0)
1426 | I0806 09:47:58.545308 11748 solver.cpp:343]     Test net output #0: accuracy = 0.9954
1427 | I0806 09:47:58.545308 11748 solver.cpp:343]     Test net output #1: loss = 0.0178642 (* 1 = 0.0178642 loss)
1428 | I0806 09:47:58.546308 11748 solver.cpp:281] Optimization Done.
1429 | I0806 09:47:58.546308 11748 caffe.cpp:134] Optimization Done.
1430 | 


--------------------------------------------------------------------------------