void caffe_powx(const int n, const Dtype* a, const Dtype b, Dtype* y);
template <typename Dtype>
+Dtype caffe_nextafter(const Dtype b);
+
+template <typename Dtype>
void caffe_vRngUniform(const int n, Dtype* r, const Dtype a, const Dtype b);
template <typename Dtype>
MultinomialLogisticLossLayerTest()
: blob_bottom_data_(new Blob<Dtype>(10, 5, 1, 1)),
blob_bottom_label_(new Blob<Dtype>(10, 1, 1, 1)) {
+ Caffe::set_random_seed(1701);
// fill the values
FillerParameter filler_param;
PositiveUnitballFiller<Dtype> filler(filler_param);
--- /dev/null
+#include <cmath>
+#include <cstring>
+#include <cuda_runtime.h>
+
+#include "gtest/gtest.h"
+#include "caffe/common.hpp"
+#include "caffe/syncedmem.hpp"
+#include "caffe/util/math_functions.hpp"
+#include "caffe/test/test_caffe_main.hpp"
+
+namespace caffe {
+
+template <typename Dtype>
+class RandomNumberGeneratorTest : public ::testing::Test {
+ public:
+ virtual ~RandomNumberGeneratorTest() {}
+
+ Dtype sample_mean(const Dtype* const seqs, const size_t sample_size)
+ {
+ double sum = 0;
+ for (int i = 0; i < sample_size; ++i) {
+ sum += seqs[i];
+ }
+ return sum / sample_size;
+ }
+
+ Dtype mean_bound(const Dtype std, const size_t sample_size)
+ {
+ return std/sqrt((double)sample_size);
+ }
+};
+
+
+typedef ::testing::Types<float, double> Dtypes;
+TYPED_TEST_CASE(RandomNumberGeneratorTest, Dtypes);
+
+TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussian) {
+ size_t sample_size = 10000;
+ SyncedMemory data_a(sample_size * sizeof(TypeParam));
+ Caffe::set_random_seed(1701);
+ TypeParam mu = 0;
+ TypeParam sigma = 1;
+ caffe_vRngGaussian(sample_size, (TypeParam*)data_a.mutable_cpu_data(), mu, sigma);
+ TypeParam true_mean = mu;
+ TypeParam true_std = sigma;
+ TypeParam bound = mean_bound(true_std, sample_size);
+ TypeParam real_mean = sample_mean((TypeParam*)data_a.cpu_data(), sample_size);
+ EXPECT_NEAR(real_mean, true_mean, bound);
+}
+
+TYPED_TEST(RandomNumberGeneratorTest, TestRngUniform) {
+ size_t sample_size = 10000;
+ SyncedMemory data_a(sample_size * sizeof(TypeParam));
+ Caffe::set_random_seed(1701);
+ TypeParam lower = 0;
+ TypeParam upper = 1;
+ caffe_vRngUniform(sample_size, (TypeParam*)data_a.mutable_cpu_data(), lower, upper);
+ TypeParam true_mean = (lower + upper) / 2;
+ TypeParam true_std = (upper - lower) / sqrt(12);
+ TypeParam bound = mean_bound(true_std, sample_size);
+ TypeParam real_mean = sample_mean((TypeParam*)data_a.cpu_data(), sample_size);
+ EXPECT_NEAR(real_mean, true_mean, bound);
+}
+
+
+
+} // namespace caffe
// Copyright 2013 Yangqing Jia
// Copyright 2014 kloudkl@github
+#include <limits>
//#include <mkl.h>
#include <eigen3/Eigen/Dense>
+#include <boost/math/special_functions/next.hpp>
#include <boost/random.hpp>
#include <cublas_v2.h>
map_vector_double_t(y, n) = const_map_vector_double_t(a, n).array().pow(b);
}
+template <typename Dtype>
+Dtype caffe_nextafter(const Dtype b) {
+ return boost::math::nextafter<Dtype, Dtype>(b, std::numeric_limits<Dtype>::max());
+}
+
template <>
void caffe_vRngUniform<float>(const int n, float* r,
const float a, const float b) {
// n, r, a, b));
// FIXME check if boundaries are handled in the same way ?
- boost::uniform_real<float> random_distribution(a, b);
+ boost::random::uniform_real_distribution<float> random_distribution(
+ a, caffe_nextafter<float>(b));
Caffe::random_generator_t &generator = Caffe::vsl_stream();
for(int i = 0; i < n; i += 1)
// n, r, a, b));
// FIXME check if boundaries are handled in the same way ?
- boost::uniform_real<double> random_distribution(a, b);
+ boost::random::uniform_real_distribution<double> random_distribution(
+ a, caffe_nextafter<double>(b));
Caffe::random_generator_t &generator = Caffe::vsl_stream();
for(int i = 0; i < n; i += 1)
template <>
void caffe_vRngGaussian<float>(const int n, float* r, const float a,
const float sigma) {
+ DCHECK(sigma > 0);
//VSL_CHECK(vsRngGaussian(VSL_RNG_METHOD_GAUSSIAN_BOXMULLER,
// Caffe::vsl_stream(), n, r, a, sigma));
template <>
void caffe_vRngGaussian<double>(const int n, double* r, const double a,
const double sigma) {
+ DCHECK(sigma > 0);
//VSL_CHECK(vdRngGaussian(VSL_RNG_METHOD_GAUSSIAN_BOXMULLER,
// Caffe::vsl_stream(), n, r, a, sigma));