: Filler<Dtype>(param) {}
virtual void Fill(Blob<Dtype>* blob) {
CHECK(blob->count());
- caffe_rng_uniform<Dtype>(blob->count(), blob->mutable_cpu_data(),
- Dtype(this->filler_param_.min()),
- Dtype(this->filler_param_.max()));
+ caffe_rng_uniform<Dtype>(blob->count(), Dtype(this->filler_param_.min()),
+ Dtype(this->filler_param_.max()), blob->mutable_cpu_data());
}
};
virtual void Fill(Blob<Dtype>* blob) {
Dtype* data = blob->mutable_cpu_data();
CHECK(blob->count());
- caffe_rng_gaussian<Dtype>(blob->count(), blob->mutable_cpu_data(),
- Dtype(this->filler_param_.mean()),
- Dtype(this->filler_param_.std()));
+ caffe_rng_gaussian<Dtype>(blob->count(), Dtype(this->filler_param_.mean()),
+ Dtype(this->filler_param_.std()), blob->mutable_cpu_data());
}
};
virtual void Fill(Blob<Dtype>* blob) {
Dtype* data = blob->mutable_cpu_data();
DCHECK(blob->count());
- caffe_rng_uniform<Dtype>(blob->count(), blob->mutable_cpu_data(), 0, 1);
+ caffe_rng_uniform<Dtype>(blob->count(), 0, 1, blob->mutable_cpu_data());
// We expect the filler to not be called very frequently, so we will
// just use a simple implementation
int dim = blob->count() / blob->num();
CHECK(blob->count());
int fan_in = blob->count() / blob->num();
Dtype scale = sqrt(Dtype(3) / fan_in);
- caffe_rng_uniform<Dtype>(blob->count(), blob->mutable_cpu_data(),
- -scale, scale);
+ caffe_rng_uniform<Dtype>(blob->count(), -scale, scale,
+ blob->mutable_cpu_data());
}
};
Dtype caffe_nextafter(const Dtype b);
template <typename Dtype>
-void caffe_rng_uniform(const int n, Dtype* r, const Dtype a, const Dtype b);
+void caffe_rng_uniform(const int n, const Dtype a, const Dtype b, Dtype* r);
template <typename Dtype>
-void caffe_rng_gaussian(const int n, Dtype* r, const Dtype a,
- const Dtype sigma);
+void caffe_rng_gaussian(const int n, const Dtype mu, const Dtype sigma,
+ Dtype* r);
template <typename Dtype>
-void caffe_rng_bernoulli(const int n, int* r, const Dtype p);
+void caffe_rng_bernoulli(const int n, const Dtype p, int* r);
template <typename Dtype>
void caffe_exp(const int n, const Dtype* a, Dtype* y);
const int count = bottom[0]->count();
if (Caffe::phase() == Caffe::TRAIN) {
// Create random numbers
- caffe_rng_bernoulli(count, mask, 1. - threshold_);
+ caffe_rng_bernoulli(count, 1. - threshold_, mask);
for (int i = 0; i < count; ++i) {
top_data[i] = bottom_data[i] * mask[i] * scale_;
}
SyncedMemory data_a(10 * sizeof(int));
SyncedMemory data_b(10 * sizeof(int));
Caffe::set_random_seed(1701);
- caffe_rng_bernoulli(10,
- reinterpret_cast<int*>(data_a.mutable_cpu_data()), 0.5);
+ caffe_rng_bernoulli(10, 0.5, static_cast<int*>(data_a.mutable_cpu_data()));
Caffe::set_random_seed(1701);
- caffe_rng_bernoulli(10,
- reinterpret_cast<int*>(data_b.mutable_cpu_data()), 0.5);
+ caffe_rng_bernoulli(10, 0.5, static_cast<int*>(data_b.mutable_cpu_data()));
for (int i = 0; i < 10; ++i) {
- EXPECT_EQ(((const int*)(data_a.cpu_data()))[i],
- ((const int*)(data_b.cpu_data()))[i]);
+ EXPECT_EQ(static_cast<const int*>(data_a.cpu_data())[i],
+ static_cast<const int*>(data_b.cpu_data())[i]);
}
}
void RngGaussianTest(const Dtype mu, const Dtype sigma, void* cpu_data) {
Dtype* rng_data = static_cast<Dtype*>(cpu_data);
- caffe_rng_gaussian(sample_size_, rng_data, mu, sigma);
+ caffe_rng_gaussian(sample_size_, mu, sigma, rng_data);
const Dtype true_mean = mu;
const Dtype true_std = sigma;
// Check that sample mean roughly matches true mean.
void RngUniformTest(const Dtype lower, const Dtype upper, void* cpu_data) {
CHECK_GE(upper, lower);
Dtype* rng_data = static_cast<Dtype*>(cpu_data);
- caffe_rng_uniform(sample_size_, rng_data, lower, upper);
+ caffe_rng_uniform(sample_size_, lower, upper, rng_data);
const Dtype true_mean = (lower + upper) / 2;
const Dtype true_std = (upper - lower) / sqrt(12);
// Check that sample mean roughly matches true mean.
void RngBernoulliTest(const Dtype p, void* cpu_data) {
int* rng_data = static_cast<int*>(cpu_data);
- caffe_rng_bernoulli(sample_size_, rng_data, p);
+ caffe_rng_bernoulli(sample_size_, p, rng_data);
const Dtype true_mean = p;
const Dtype true_std = sqrt(p * (1 - p));
const Dtype bound = this->mean_bound(true_std);
double caffe_nextafter(const double b);
template <typename Dtype>
-void caffe_rng_uniform(const int n, Dtype* r,
- const Dtype a, const Dtype b) {
+void caffe_rng_uniform(const int n, const Dtype a, const Dtype b, Dtype* r) {
CHECK_GE(n, 0);
CHECK(r);
CHECK_LE(a, b);
}
template
-void caffe_rng_uniform<float>(const int n, float* r,
- const float a, const float b);
+void caffe_rng_uniform<float>(const int n, const float a, const float b,
+ float* r);
+
template
-void caffe_rng_uniform<double>(const int n, double* r,
- const double a, const double b);
+void caffe_rng_uniform<double>(const int n, const double a, const double b,
+ double* r);
template <typename Dtype>
-void caffe_rng_gaussian(const int n, Dtype* r, const Dtype a,
- const Dtype sigma) {
+void caffe_rng_gaussian(const int n, const Dtype a,
+ const Dtype sigma, Dtype* r) {
CHECK_GE(n, 0);
CHECK(r);
CHECK_GT(sigma, 0);
}
template
-void caffe_rng_gaussian<float>(const int n, float* r, const float a,
- const float sigma);
+void caffe_rng_gaussian<float>(const int n, const float mu,
+ const float sigma, float* r);
template
-void caffe_rng_gaussian<double>(const int n, double* r, const double a,
- const double sigma);
+void caffe_rng_gaussian<double>(const int n, const double mu,
+ const double sigma, double* r);
template <typename Dtype>
-void caffe_rng_bernoulli(const int n, int* r, const Dtype p) {
+void caffe_rng_bernoulli(const int n, const Dtype p, int* r) {
CHECK_GE(n, 0);
CHECK(r);
CHECK_GE(p, 0);
}
template
-void caffe_rng_bernoulli<double>(const int n, int* r, const double p);
+void caffe_rng_bernoulli<double>(const int n, const double p, int* r);
template
-void caffe_rng_bernoulli<float>(const int n, int* r, const float p);
+void caffe_rng_bernoulli<float>(const int n, const float p, int* r);
template <>
float caffe_cpu_dot<float>(const int n, const float* x, const float* y) {