bottom_data[h * WIDTH_ + w];
}
}
+ top_data[ph * POOLED_WIDTH_ + pw] /=
+ (hend - hstart) * (wend - wstart);
}
}
// compute offset
top_data += (*top)[0]->offset(0, 1);
}
}
- // Our implementation simply divides the pooled values by KSIZE^2,
- // regardless of the actual pooling region. This would allow one to not
- // trust too much on the border pooling regions, but I am not sure what
- // benefit / harm it would bring to the actual code.
- caffe_scal<Dtype>(top_count, Dtype(1.) / KSIZE_ / KSIZE_,
- (*top)[0]->mutable_cpu_data());
break;
default:
LOG(FATAL) << "Unknown pooling method.";
int wstart = pw * STRIDE_;
int hend = min(hstart + KSIZE_, HEIGHT_);
int wend = min(wstart + KSIZE_, WIDTH_);
+ int poolsize = (hend - hstart) * (wend - wstart);
for (int h = hstart; h < hend; ++h) {
for (int w = wstart; w < wend; ++w) {
bottom_diff[h * WIDTH_ + w] +=
- top_diff[ph * POOLED_WIDTH_ + pw];
+ top_diff[ph * POOLED_WIDTH_ + pw] / poolsize;
}
}
}
top_diff += top[0]->offset(0, 1);
}
}
- // Our implementation simply divides the pooled values by KSIZE^2,
- // regardless of the actual pooling region. This would allow one to not
- // trust too much on the border pooling regions, but I am not sure what
- // benefit / harm it would bring to the actual code.
- caffe_scal<Dtype>((*bottom)[0]->count(), Dtype(1.) / KSIZE_ / KSIZE_,
- (*bottom)[0]->mutable_cpu_diff());
break;
default:
LOG(FATAL) << "Unknown pooling method.";
aveval += bottom_data[h * width + w];
}
}
- top_data[index] = aveval / ksize / ksize;
+ top_data[index] = aveval / (hend - hstart) / (wend - wstart);
} // (if index < nthreads)
}
int pwstart = (w < ksize) ? 0 : (w - ksize) / stride + 1;
int pwend = min(w / stride + 1, pooled_width);
Dtype gradient = 0;
- Dtype bottom_datum =
+ Dtype bottom_datum =
bottom_data[((n * channels + c) * height + h) * width + w];
top_data += (n * channels + c) * pooled_height * pooled_width;
top_diff += (n * channels + c) * pooled_height * pooled_width;
top_diff += (n * channels + c) * pooled_height * pooled_width;
for (int ph = phstart; ph < phend; ++ph) {
for (int pw = pwstart; pw < pwend; ++pw) {
- gradient += top_diff[ph * pooled_width + pw];
+ // figure out the pooling size
+ int poolsize = (min(ph * stride + ksize, height) - ph * stride) *
+ (min(pw * stride + ksize, width) - pw * stride);
+ if (poolsize <= 0) {
+ printf("error: %d %d %d %d %d\n", ph, pw, ksize, height, width);
+ }
+ gradient += top_diff[ph * pooled_width + pw] / poolsize;
}
}
- bottom_diff[index] = gradient / ksize / ksize;
+ bottom_diff[index] = gradient;
} // (if index < nthreads)
}
+++ /dev/null
-name: "LeNet"
-layers {
- layer {
- name: "mnist"
- type: "data"
- source: "caffe/test/data/mnist-train-leveldb"
- batchsize: 128
- scale: 0.00390625
- cropsize: 26
- }
- top: "data"
- top: "label"
-}
-layers {
- layer {
- name: "conv1"
- type: "conv"
- num_output: 20
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "data"
- top: "conv1"
-}
-layers {
- layer {
- name: "pool1"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv1"
- top: "pool1"
-}
-layers {
- layer {
- name: "conv2"
- type: "conv"
- num_output: 50
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool1"
- top: "conv2"
-}
-layers {
- layer {
- name: "pool2"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv2"
- top: "pool2"
-}
-layers {
- layer {
- name: "ip1"
- type: "innerproduct"
- num_output: 500
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool2"
- top: "ip1"
-}
-layers {
- layer {
- name: "relu1"
- type: "relu"
- }
- bottom: "ip1"
- top: "relu1"
-}
-layers {
- layer {
- name: "ip2"
- type: "innerproduct"
- num_output: 10
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "relu1"
- top: "ip2"
-}
-layers {
- layer {
- name: "prob"
- type: "softmax"
- }
- bottom: "ip2"
- top: "prob"
-}
-layers {
- layer {
- name: "loss"
- type: "multinomial_logistic_loss"
- }
- bottom: "prob"
- bottom: "label"
-}
+++ /dev/null
-name: "LeNet-test"
-layers {
- layer {
- name: "mnist"
- type: "data"
- source: "caffe/test/data/mnist-test-leveldb"
- batchsize: 100
- scale: 0.00390625
- cropsize: 26
- }
- top: "data"
- top: "label"
-}
-layers {
- layer {
- name: "conv1"
- type: "conv"
- num_output: 20
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "data"
- top: "conv1"
-}
-layers {
- layer {
- name: "pool1"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv1"
- top: "pool1"
-}
-layers {
- layer {
- name: "conv2"
- type: "conv"
- num_output: 50
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool1"
- top: "conv2"
-}
-layers {
- layer {
- name: "pool2"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv2"
- top: "pool2"
-}
-layers {
- layer {
- name: "ip1"
- type: "innerproduct"
- num_output: 500
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool2"
- top: "ip1"
-}
-layers {
- layer {
- name: "relu1"
- type: "relu"
- }
- bottom: "ip1"
- top: "relu1"
-}
-layers {
- layer {
- name: "ip2"
- type: "innerproduct"
- num_output: 10
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "relu1"
- top: "ip2"
-}
-layers {
- layer {
- name: "prob"
- type: "softmax"
- }
- bottom: "ip2"
- top: "prob"
-}
-layers {
- layer {
- name: "accuracy"
- type: "accuracy"
- }
- bottom: "prob"
- bottom: "label"
- top: "accuracy"
-}
+++ /dev/null
-name: "LeNet-test"
-layers {
- layer {
- name: "mnist"
- type: "data"
- source: "caffe/test/data/mnist-train-leveldb"
- batchsize: 100
- scale: 0.00390625
- cropsize: 26
- }
- top: "data"
- top: "label"
-}
-layers {
- layer {
- name: "conv1"
- type: "conv"
- num_output: 20
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "data"
- top: "conv1"
-}
-layers {
- layer {
- name: "pool1"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv1"
- top: "pool1"
-}
-layers {
- layer {
- name: "conv2"
- type: "conv"
- num_output: 50
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool1"
- top: "conv2"
-}
-layers {
- layer {
- name: "pool2"
- type: "pool"
- kernelsize: 2
- stride: 2
- pool: MAX
- }
- bottom: "conv2"
- top: "pool2"
-}
-layers {
- layer {
- name: "ip1"
- type: "innerproduct"
- num_output: 500
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "pool2"
- top: "ip1"
-}
-layers {
- layer {
- name: "relu1"
- type: "relu"
- }
- bottom: "ip1"
- top: "relu1"
-}
-layers {
- layer {
- name: "ip2"
- type: "innerproduct"
- num_output: 10
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "relu1"
- top: "ip2"
-}
-layers {
- layer {
- name: "prob"
- type: "softmax"
- }
- bottom: "ip2"
- top: "prob"
-}
-layers {
- layer {
- name: "accuracy"
- type: "accuracy"
- }
- bottom: "prob"
- bottom: "label"
- top: "accuracy"
-}
+++ /dev/null
-name: "linear_regression_net"
-layers {
- layer {
- name: "datalayer"
- type: "data"
- source: "caffe/test/data/simple-linear-regression-leveldb"
- batchsize: 32
- }
- top: "data"
- top: "label"
-}
-layers {
- layer {
- name: "ip"
- type: "innerproduct"
- num_output: 1
- weight_filler {
- type: "xavier"
- }
- bias_filler {
- type: "constant"
- }
- }
- bottom: "data"
- top: "ip"
-}
-layers {
- layer {
- name: "loss"
- type: "euclidean_loss"
- }
- bottom: "ip"
- bottom: "label"
-}
+++ /dev/null
-"""This script generates the mnist train and test leveldbs used in the
-test.
-"""
-from caffe.pyutil import convert
-from decaf.layers import core_layers
-import numpy as np
-import leveldb
-
-# the folder that has the MNIST data
-MNIST_ROOT = 'mnist'
-
-mnist = core_layers.MNISTDataLayer(
- rootfolder=MNIST_ROOT, name='mnist', is_training = True)
-db = leveldb.LevelDB('mnist-train-leveldb')
-
-for i in range(60000):
- datum = convert.array_to_datum((mnist._data[i] * 255).reshape(1,28,28).astype(np.uint8))
- datum.label = mnist._label[i]
- db.Put('%d' % (i), datum.SerializeToString())
-del db
-
-mnist = core_layers.MNISTDataLayer(
- rootfolder=MNIST_ROOT, name='mnist', is_training = False)
-db = leveldb.LevelDB('mnist-test-leveldb')
-
-for i in range(10000):
- datum = convert.array_to_datum((mnist._data[i] * 255).reshape(1,28,28).astype(np.uint8))
- datum.label = mnist._label[i]
- db.Put('%d' % (i), datum.SerializeToString())
-del db
+++ /dev/null
-name: "SimpleConv"
-input: "data"
-layers {
- layer {
- name: "conv"
- type: "conv"
- num_output: 1
- kernelsize: 5
- stride: 1
- weight_filler {
- type: "constant"
- value: 0.01333333
- }
- biasterm: false
- }
- bottom: "data"
- top: "smooth"
-}
+++ /dev/null
-"""This script generates the mnist train and test leveldbs used in the
-test.
-"""
-from caffe.pyutil import convert
-import numpy as np
-import leveldb
-
-db = leveldb.LevelDB('simple-linear-regression-leveldb')
-
-for i in range(1000):
- label = np.random.randint(2) * 2 - 1
- arr = np.random.randn(2,1,1) + label
- datum = convert.array_to_datum(arr)
- datum.label = label
- db.Put('%d' % (i), datum.SerializeToString())
-del db
TYPED_TEST(NetProtoTest, TestSetup) {
NetParameter net_param;
- ReadProtoFromTextFile("caffe/test/data/lenet.prototxt", &net_param);
+ ReadProtoFromTextFile("data/lenet.prototxt", &net_param);
// check if things are right
EXPECT_EQ(net_param.layers_size(), 10);
EXPECT_EQ(net_param.input_size(), 0);
TYPED_TEST(NetProtoTest, TestLoadFromText) {
NetParameter net_param;
- ReadProtoFromTextFile("caffe/test/data/simple_conv.prototxt", &net_param);
+ ReadProtoFromTextFile("data/simple_conv.prototxt", &net_param);
Blob<TypeParam> lena_image;
- ReadImageToBlob<TypeParam>(string("caffe/test/data/lena_256.jpg"), &lena_image);
+ ReadImageToBlob<TypeParam>(string("data/lena_256.jpg"), &lena_image);
vector<Blob<TypeParam>*> bottom_vec;
bottom_vec.push_back(&lena_image);
Caffe::set_mode(Caffe::GPU);
NetParameter net_param;
- ReadProtoFromTextFile("caffe/test/data/linear_regression.prototxt",
+ ReadProtoFromTextFile("data/linear_regression.prototxt",
&net_param);
// check if things are right
EXPECT_EQ(net_param.layers_size(), 3);
Caffe::set_mode(Caffe::GPU);
NetParameter net_param;
- ReadProtoFromTextFile("caffe/test/data/lenet.prototxt",
+ ReadProtoFromTextFile("data/lenet.prototxt",
&net_param);
vector<Blob<float>*> bottom_vec;
Net<float> caffe_net(net_param, bottom_vec);
caffe_net.ToProto(&trained_net_param);
NetParameter traintest_net_param;
- ReadProtoFromTextFile("caffe/test/data/lenet_traintest.prototxt",
+ ReadProtoFromTextFile("data/lenet_traintest.prototxt",
&traintest_net_param);
Net<float> caffe_traintest_net(traintest_net_param, bottom_vec);
caffe_traintest_net.CopyTrainedLayersFrom(trained_net_param);
LOG(ERROR) << "Train accuracy:" << train_accuracy;
NetParameter test_net_param;
- ReadProtoFromTextFile("caffe/test/data/lenet_test.prototxt", &test_net_param);
+ ReadProtoFromTextFile("data/lenet_test.prototxt", &test_net_param);
Net<float> caffe_test_net(test_net_param, bottom_vec);
caffe_test_net.CopyTrainedLayersFrom(trained_net_param);
LOG(ERROR) << "Initial loss: " << caffe_net.Backward();
SolverParameter solver_param;
- solver_param.set_base_lr(0.002);
+ solver_param.set_base_lr(0.001);
solver_param.set_display(1);
- solver_param.set_max_iter(600000);
+ solver_param.set_max_iter(60000);
solver_param.set_lr_policy("fixed");
solver_param.set_momentum(0.9);
solver_param.set_weight_decay(0.0005);