compiler/souschef/src/Gaussian.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "souschef/Data/Gaussian.h"
  18 #include "souschef/LexicalCast.h"
  19
  20 #include <random>
  21 #include <chrono>
  22
  23 #include <cassert>
  24 #include <stdexcept>
  25 #include <limits> // std::numeric_limits
  26
  27 #include <fp16.h>
  28
  29 namespace souschef
  30 {
  31
  32 template <typename T>
  33 static std::vector<uint8_t> generate_gaussian(int32_t count, float mean, float stddev,
  34                                               std::minstd_rand::result_type seed)
  35 {
  36   std::minstd_rand rand{static_cast<std::minstd_rand::result_type>(seed)};
  37   std::normal_distribution<float> dist{mean, stddev};
  38
  39   std::vector<uint8_t> res;
  40
  41   constexpr float max_cap = std::numeric_limits<T>::max();
  42   constexpr float min_cap = std::numeric_limits<T>::lowest();
  43   for (uint32_t n = 0; n < count; ++n)
  44   {
  45     float raw_value = dist(rand);
  46     const float capped_value = std::max(min_cap, std::min(max_cap, raw_value));
  47     auto const value = static_cast<T>(capped_value);
  48     auto const arr = reinterpret_cast<const uint8_t *>(&value);
  49
  50     for (uint32_t b = 0; b < sizeof(T); ++b)
  51     {
  52       res.emplace_back(arr[b]);
  53     }
  54   }
  55
  56   return res;
  57 }
  58
  59 template <typename T>
  60 static std::vector<uint8_t> generate_gaussian(int32_t count, float mean, float stddev)
  61 {
  62   auto time_stamp = std::chrono::system_clock::now().time_since_epoch().count();
  63
  64   // Note this is implementation defined, change if needed.
  65   auto seed = static_cast<std::minstd_rand::result_type>(time_stamp);
  66
  67   return generate_gaussian<T>(count, mean, stddev, seed);
  68 }
  69
  70 std::vector<uint8_t> GaussianFloat32DataChef::generate(int32_t count) const
  71 {
  72   return generate_gaussian<float>(count, _mean, _stddev);
  73 }
  74
  75 std::vector<uint8_t> GaussianFloat16DataChef::generate(int32_t count) const
  76 {
  77   auto time_stamp = std::chrono::system_clock::now().time_since_epoch().count();
  78   auto seed = static_cast<std::minstd_rand::result_type>(time_stamp);
  79
  80   std::minstd_rand rand{static_cast<std::minstd_rand::result_type>(seed)};
  81   std::normal_distribution<float> dist{_mean, _stddev};
  82
  83   std::vector<uint8_t> res;
  84
  85   constexpr float max_cap = 1e9;
  86   constexpr float min_cap = -1e9;
  87   for (uint32_t n = 0; n < count; ++n)
  88   {
  89     float raw_value = dist(rand);
  90     const float capped_value = std::max(min_cap, std::min(max_cap, raw_value));
  91     const uint16_t value = fp16_ieee_from_fp32_value(capped_value);
  92     auto const arr = reinterpret_cast<const uint8_t *>(&value);
  93
  94     for (uint32_t b = 0; b < sizeof(uint16_t); ++b)
  95     {
  96       res.emplace_back(arr[b]);
  97     }
  98   }
  99
 100   return res;
 101 }
 102
 103 std::vector<uint8_t> GaussianInt32DataChef::generate(int32_t count) const
 104 {
 105   return generate_gaussian<int32_t>(count, _mean, _stddev);
 106 }
 107
 108 std::vector<uint8_t> GaussianInt16DataChef::generate(int32_t count) const
 109 {
 110   return generate_gaussian<int16_t>(count, _mean, _stddev);
 111 }
 112
 113 std::vector<uint8_t> GaussianUint8DataChef::generate(int32_t count) const
 114 {
 115   return generate_gaussian<uint8_t>(count, _mean, _stddev);
 116 }
 117
 118 std::unique_ptr<DataChef> GaussianFloat32DataChefFactory::create(const Arguments &args) const
 119 {
 120   if (args.count() != 2)
 121   {
 122     throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
 123   }
 124
 125   auto const mean = to_number<float>(args.value(0));
 126   auto const stddev = to_number<float>(args.value(1));
 127
 128   return std::unique_ptr<DataChef>{new GaussianFloat32DataChef{mean, stddev}};
 129 }
 130
 131 std::unique_ptr<DataChef> GaussianInt32DataChefFactory::create(const Arguments &args) const
 132 {
 133   if (args.count() != 2)
 134   {
 135     throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
 136   }
 137
 138   auto const mean = to_number<float>(args.value(0));
 139   auto const stddev = to_number<float>(args.value(1));
 140
 141   return std::unique_ptr<DataChef>{new GaussianInt32DataChef{mean, stddev}};
 142 }
 143
 144 std::unique_ptr<DataChef> GaussianInt16DataChefFactory::create(const Arguments &args) const
 145 {
 146   if (args.count() != 2)
 147   {
 148     throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
 149   }
 150
 151   auto const mean = to_number<float>(args.value(0));
 152   auto const stddev = to_number<float>(args.value(1));
 153
 154   return std::unique_ptr<DataChef>{new GaussianInt16DataChef{mean, stddev}};
 155 }
 156
 157 std::unique_ptr<DataChef> GaussianUint8DataChefFactory::create(const Arguments &args) const
 158 {
 159   if (args.count() != 2)
 160   {
 161     throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
 162   }
 163
 164   auto const mean = to_number<float>(args.value(0));
 165   auto const stddev = to_number<float>(args.value(1));
 166
 167   return std::unique_ptr<DataChef>{new GaussianUint8DataChef{mean, stddev}};
 168 }
 169
 170 std::unique_ptr<DataChef> GaussianFloat16DataChefFactory::create(const Arguments &args) const
 171 {
 172   if (args.count() != 2)
 173   {
 174     throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
 175   }
 176
 177   auto const mean = to_number<float>(args.value(0));
 178   auto const stddev = to_number<float>(args.value(1));
 179
 180   return std::unique_ptr<DataChef>{new GaussianFloat16DataChef{mean, stddev}};
 181 }
 182
 183 } // namespace souschef