| // Copyright 2016 The Gemmlowp Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include <unistd.h> |
| #ifdef __APPLE__ |
| #include <sys/time.h> |
| #endif |
| |
| #include <cstdint> |
| #include <cstdlib> |
| #include <ctime> |
| #include <iomanip> |
| #include <iostream> |
| #include <map> |
| #include <memory> |
| #include <vector> |
| |
| #include "single_thread_transform.h" |
| #include "transform_kernels.h" |
| |
| #define EPSILON (0.0001) |
| |
| using namespace gemmlowp::meta; |
| |
| typedef Transform1DParams<std::int32_t, std::uint8_t, Requantize> RequantizeParams; |
| typedef Transform1DParams<float, std::uint8_t, Quantize> QuantizeParams; |
| typedef Transform1DParams<std::uint8_t, float, Dequantize> DequantizeParams; |
| typedef Transform1DParams<std::uint8_t, std::uint8_t, MinMax<std::uint8_t>> MinMaxParams; |
| typedef Transform1DParams<std::uint8_t, std::int32_t, BiasAdd<std::uint8_t>> BiasAddParams; |
| |
| void prepare_data_requantize(int count, std::int32_t* data) { |
| float scale = 4000000000.0f / static_cast<float>(count - 1); |
| for (int i = 0; i < count; ++i) { |
| float temp = -2000000000.0f + scale * i; |
| data[i] = static_cast<std::int32_t>(temp); |
| } |
| } |
| |
| void prepare_data_quantize(int count, float* data) { |
| float scale = 200.0f / static_cast<float>(count - 1); |
| for (int i = 0; i < count; ++i) { |
| data[i] = -100 + scale * i; |
| } |
| } |
| |
| void prepare_data_dequantize(int count, std::uint8_t* data) { |
| for (int i = 0; i < count; ++i) { |
| data[i] = static_cast<std::uint8_t>(i % 256); |
| } |
| } |
| |
| void prepare_data_minmax(int count, std::uint8_t* data) { |
| for (int i = 0; i < count; ++i) { |
| data[i] = static_cast<std::uint8_t>(i % 256); |
| } |
| } |
| |
| void prepare_data_biasadd(int count, std::uint8_t* data) { |
| for (int i = 0; i < count; ++i) { |
| data[i] = static_cast<std::uint8_t>(i % 256); |
| } |
| } |
| |
| void verify_requantize(const RequantizeParams& params) { |
| for (int i = 0; i < params.kernel.count; ++i) { |
| std::uint8_t actual = params.output[i]; |
| float expected = static_cast<float>(params.input[i]); |
| expected -= params.kernel.input_range_offset; |
| expected *= params.kernel.input_range_scale; |
| expected += params.kernel.input_range_min; |
| expected -= params.kernel.output_range_min; |
| expected *= params.kernel.one_over_output_range_scale; |
| expected += params.kernel.output_range_offset; |
| std::uint8_t expected_uint8 = static_cast<std::uint8_t>(expected); |
| |
| if (actual != expected_uint8) { |
| std::cout << "Wrong: " << i << " : " << actual << " vs. " |
| << expected_uint8 << std::endl; |
| std::exit(1); |
| } |
| } |
| std::cout << "Requantize: OK" << std::endl; |
| } |
| |
| void verify_quantize(const QuantizeParams& params) { |
| for (int i = 0; i < params.kernel.count; ++i) { |
| std::uint8_t actual = params.output[i]; |
| float expected = params.input[i]; |
| expected -= params.kernel.range_min; |
| expected *= params.kernel.range_scale; |
| expected += params.kernel.range_offset; |
| std::uint8_t expected_uint8 = static_cast<std::uint8_t>(expected); |
| |
| if (actual != expected_uint8) { |
| std::cout << "Wrong: " << i << " : " << actual << " vs. " |
| << expected_uint8 << std::endl; |
| std::exit(1); |
| } |
| } |
| std::cout << "Quantize: OK" << std::endl; |
| } |
| |
| void verify_dequantize(const DequantizeParams& params) { |
| for (int i = 0; i < params.kernel.count; ++i) { |
| float actual = params.output[i]; |
| float expected = static_cast<float>(params.input[i]); |
| expected -= params.kernel.range_offset; |
| expected *= params.kernel.range_scale; |
| expected += params.kernel.range_min; |
| if (std::abs(actual - expected) > EPSILON) { |
| std::cout << std::setprecision(9) << "Wrong: " << i << " : " << actual |
| << " vs. " << expected << std::endl; |
| std::exit(1); |
| } |
| } |
| std::cout << "Dequantize: OK" << std::endl; |
| } |
| |
| void verify_minmax(const MinMaxParams& params) { |
| for (int i = 0; i < params.kernel.count; ++i) { |
| std::uint8_t actual = params.output[i]; |
| std::uint8_t expected = params.input[i]; |
| expected = std::min(expected, params.kernel.max); |
| expected = std::max(expected, params.kernel.min); |
| |
| if (actual != expected) { |
| std::cout << "Wrong: " << i << " : " << actual << " vs. " << expected |
| << std::endl; |
| std::exit(1); |
| } |
| } |
| std::cout << "MinMax: OK" << std::endl; |
| } |
| |
| void verify_biasadd(const BiasAddParams& params) { |
| for (int i = 0; i < params.kernel.rows * params.kernel.count; ++i) { |
| std::int32_t actual = params.output[i]; |
| std::uint8_t input = params.input[i]; |
| std::uint8_t bias = params.kernel.bias[i % params.kernel.count]; |
| float input_float = static_cast<float>(input); |
| input_float -= params.kernel.input_range_offset; |
| input_float *= params.kernel.input_range_scale; |
| input_float += params.kernel.input_range_min; |
| float bias_float = static_cast<float>(bias); |
| bias_float -= params.kernel.bias_range_offset; |
| bias_float *= params.kernel.bias_range_scale; |
| bias_float += params.kernel.bias_range_min; |
| float sum = input_float + bias_float; |
| sum -= params.kernel.output_range_min; |
| sum *= params.kernel.one_over_output_range_scale; |
| sum += params.kernel.output_range_offset; |
| std::int32_t expected = static_cast<std::int32_t>(sum); |
| if (std::abs(actual - expected) > 1024) { |
| std::cout << "Wrong: " << i << " : " << actual << " vs. " << expected |
| << std::endl; |
| std::exit(1); |
| } |
| } |
| std::cout << "BiasAdd: OK" << std::endl; |
| } |
| |
| int main() { |
| std::unique_ptr<std::int32_t[]> array_int32(new std::int32_t[128 * 1024]); |
| std::unique_ptr<std::uint8_t[]> array_uint8(new std::uint8_t[128 * 1024]); |
| std::unique_ptr<std::uint8_t[]> array_uint8_2(new std::uint8_t[128 * 1024]); |
| std::unique_ptr<float[]> array_float(new float[128 * 1024]); |
| |
| { |
| RequantizeParams requantize_params; |
| requantize_params.input = array_int32.get(); |
| requantize_params.output = array_uint8.get(); |
| requantize_params.kernel.count = 12345; |
| requantize_params.kernel.input_range_min = -100.0f; |
| requantize_params.kernel.input_range_scale = |
| 200.0f / ((static_cast<std::int64_t>(1) << 32) - 1); |
| requantize_params.kernel.input_range_offset = |
| static_cast<float>(std::numeric_limits<std::int32_t>::lowest()); |
| requantize_params.kernel.output_range_min = -100.f; |
| requantize_params.kernel.one_over_output_range_scale = |
| static_cast<float>((static_cast<std::int64_t>(1) << 8) - 1) / 200.0f; |
| requantize_params.kernel.output_range_offset = |
| static_cast<float>(std::numeric_limits<std::uint8_t>::lowest()); |
| |
| prepare_data_requantize(12345, array_int32.get()); |
| |
| Transform1D<RequantizeParams, 16>(requantize_params); |
| |
| verify_requantize(requantize_params); |
| } |
| |
| { |
| QuantizeParams quantize_params; |
| quantize_params.input = array_float.get(); |
| quantize_params.output = array_uint8.get(); |
| quantize_params.kernel.count = 12345; |
| quantize_params.kernel.range_min = -100.0f; |
| quantize_params.kernel.range_scale = |
| static_cast<float>((static_cast<std::int64_t>(1) << 8) - 1) / 200.0f; |
| quantize_params.kernel.range_offset = |
| static_cast<float>(std::numeric_limits<std::uint8_t>::lowest()); |
| |
| prepare_data_quantize(12345, array_float.get()); |
| |
| Transform1D<QuantizeParams, 16>(quantize_params); |
| |
| verify_quantize(quantize_params); |
| } |
| |
| { |
| DequantizeParams dequantize_params; |
| dequantize_params.input = array_uint8.get(); |
| dequantize_params.output = array_float.get(); |
| dequantize_params.kernel.count = 12345; |
| dequantize_params.kernel.range_min = -100.0f; |
| dequantize_params.kernel.range_scale = |
| 200.0f / ((static_cast<std::int64_t>(1) << 8) - 1); |
| dequantize_params.kernel.range_offset = |
| static_cast<float>(std::numeric_limits<std::uint8_t>::lowest()); |
| |
| prepare_data_dequantize(12345, array_uint8.get()); |
| |
| Transform1D<DequantizeParams, 16>(dequantize_params); |
| |
| verify_dequantize(dequantize_params); |
| } |
| |
| { |
| MinMaxParams minmax_params; |
| minmax_params.input = array_uint8.get(); |
| minmax_params.output = array_uint8_2.get(); |
| minmax_params.kernel.count = 12345; |
| minmax_params.kernel.min = 64; |
| minmax_params.kernel.max = 192; |
| |
| prepare_data_minmax(12345, array_uint8.get()); |
| |
| Transform1D<MinMaxParams, 16>(minmax_params); |
| |
| verify_minmax(minmax_params); |
| } |
| |
| { |
| BiasAddParams biasadd_params; |
| biasadd_params.input = array_uint8.get(); |
| biasadd_params.output = array_int32.get(); |
| biasadd_params.kernel.count = 1234; |
| biasadd_params.kernel.rows = 11; |
| biasadd_params.kernel.input_range_min = -100.0f; |
| biasadd_params.kernel.bias_range_min = -100.0f; |
| biasadd_params.kernel.output_range_min = -250.0f; |
| biasadd_params.kernel.input_range_offset = |
| static_cast<float>(std::numeric_limits<std::uint8_t>::lowest()); |
| biasadd_params.kernel.bias_range_offset = |
| static_cast<float>(std::numeric_limits<std::uint8_t>::lowest()); |
| biasadd_params.kernel.output_range_offset = |
| static_cast<float>(std::numeric_limits<std::int32_t>::lowest()); |
| biasadd_params.kernel.input_range_scale = |
| 200.0f / ((static_cast<std::int64_t>(1) << 8) - 1); |
| biasadd_params.kernel.bias_range_scale = |
| 200.0f / ((static_cast<std::int64_t>(1) << 8) - 1); |
| biasadd_params.kernel.one_over_output_range_scale = |
| static_cast<float>((static_cast<std::int64_t>(1) << 32) - 1) / 500.0f; |
| biasadd_params.kernel.bias = array_uint8_2.get(); |
| |
| prepare_data_biasadd(1234 * 11, array_uint8.get()); |
| prepare_data_biasadd(1234, array_uint8_2.get()); |
| |
| Transform1D<BiasAddParams, 16>(biasadd_params); |
| |
| verify_biasadd(biasadd_params); |
| } |
| |
| return 0; |
| } |