Oct 28, 2017 · Oct 28, 2017 · Oct 29, 2017 · Oct 29, 2017 · Oct 29, 2017 · Oct 29, 2017
diff --git a/.gitignore b/.gitignore

 #Project generated test files
 TESTS/scripts/testData

 #Vim stuff
 *.swp
diff --git a/ArrayOps.hpp b/ArrayOps.hpp
 #include <math.h>
 #include "uTensor_util.hpp"
 #include "quantization_utils.hpp"
 #include "uTensorBase.hpp"

 //T = inferred
 //mode = MIN_FIRST
 //name = unspecified
 template <typename T>
 void QuantizeV2(Tensor<float> input,Tensor<float> _min_range,Tensor<float> _max_range,
 Tensor<T> output,Tensor<float> output_min,Tensor<float> output_max) {
 void QuantizeV2(S_TENSOR input,S_TENSOR _min_range,S_TENSOR _max_range,
 S_TENSOR output,S_TENSOR output_min,S_TENSOR output_max) {

    float input_min_range = *(_min_range.getPointer({0}));
    float input_max_range = *(_max_range.getPointer({0}));
    float input_min_range = *(_min_range->read<float>(0, 0));
    float input_max_range = *(_max_range->read<float>(0, 0));

    if(input_max_range < input_min_range) ERR_EXIT("input_max_range must be larger than input_min_range.");

    float min_range = std::min(0.0f, input_min_range);
    const float epsilon = std::max(1.0f, std::max(fabsf(input_min_range),
                                                   fabsf(input_max_range))) / 100.0f;
    std::vector<uint32_t> v;

    std::vector<uint32_t> org = input->getShape();
    for (int i = org.size() - 1; i >= 0; i--) {
        v.push_back(org[i]);
    }

    if(output && output->getSize() == 0) {
      output->resize<T>(v);
    }

    float max_range = std::max(input_max_range, min_range + epsilon);
    max_range = std::max(0.0f, max_range);

    FloatToQuantizedStruct<T> f2q(min_range, max_range);

    //quantization_utils.h:149
    float* input_ptr = input.getPointer({});
    T* output_ptr = output.getPointer({});
    float* output_min_ptr = output_min.getPointer({0});
    float* output_max_ptr = output_max.getPointer({0});
 constfloat* input_ptr = input->read<float>(0, 0);
    T* output_ptr = output->write<T>(0, 0);
    float* output_min_ptr = output_min->write<float>(0, 0);
    float* output_max_ptr = output_max->write<float>(0, 0);

    ///NT: need error checking at some point...
    for(uint32_t i = 0; i < input.getSize(); i++) {
    for(uint32_t i = 0; i < input->getSize(); i++) {
        float val = std::round(input_ptr[i] * f2q.range_scale);
        val -= f2q.range_min_scaled - f2q.lowest_quantized();
        val = std::max(val, f2q.lower_bound_float());

 }

 class QuantizeV2Op : public Operator {
  public:
    QuantizeV2Op() {
      n_inputs = 3;
      n_outputs = 3;
    }

    virtual void compute() override {
      QuantizeV2<unsigned char>(inputs[0], inputs[1], inputs[2],
              outputs[0], outputs[1], outputs[2]);
    }
 };

 //mode = MIN_FIRST
 //name = unspecified
 //dequantize_op.cc: 87
 template <typename T>
 void dequantize(Tensor<T> input,Tensor<float> min_range,Tensor<float> max_range,Tensor<float> &output) {
    float min = *(min_range.getPointer({0}));
    float max = *(max_range.getPointer({0}));
 void dequantize(S_TENSOR input,S_TENSOR min_range,S_TENSOR max_range,S_TENSORoutput) {
    float min = *(min_range->read<float>(0, 0));
    float max = *(max_range->read<float>(0, 0));
      //auto tensor allocation
    Shape out_shape;
 tensorChkAlloc(output,input.getShape());
    output->resize<float>(input->getShape());

    T* input_ptr = input.getPointer({});
    float* output_ptr = output.getPointer({});
 constT* input_ptr = input->read<T>(0, 0);
    float* output_ptr = output->write<float>(0, 0);

    //quantization_utils.h: 771
    QuantizedToFloatStruct<T> q2f(min, max);

    //quantization_utils.h: 141
    for(uint32_t i = 0; i < input.getSize(); i++) {
    for(uint32_t i = 0; i < input->getSize(); i++) {
        float val = static_cast<float>(input_ptr[i]);
        output_ptr[i] = ((q2f.range_min_rounded - q2f.lowest_quantized() * q2f.range_scale) + \
                        val * q2f.range_scale);
    }
 }
 class DequantizeOp : public Operator {
  public:
    DequantizeOp() {
      n_inputs = 3;
      n_outputs = 1;
    }

    virtual void compute() override {
      dequantize<unsigned char>(inputs[0], inputs[1], inputs[2],
              outputs[0]);
    }
 };
 /*
  number_of_steps = 1 << (# of bits in T)
  range_adjust = number_of_steps / (number_of_steps - 1)
    //     output_ptr[i] = QuantizedToFloat(input_ptr[i], min, max);
    // }

 }

 //Pre:
 //output.getShape == shape, or

 ///NT: This Op hasn't been tested extensively. We will have to increase the test-coverage for this function.
 template <typename T>
 void reshape(Tensor<T> input,Tensor<int> shape,Tensor<T> &output) {
 void reshape(S_TENSOR input,S_TENSOR shape,S_TENSORoutput) {
    Shape dim;
    uint32_t t = input->getShape().size();
    if (t == 0) {
        t = 1;
    }

    shape->resize<int>({t});

    if (t == 1) {
        shape->write<int>(0, 0)[0] = -1;
    } else {
        shape->write<int>(0, 0)[0] = input->getSize();
        shape->write<int>(0, 0)[1] = -1;
    }

    //validating and inferring dimensions
    int infer_index = -1;
    uint32_t dim_rem = input.getSize();
    int* val = shape.getPointer({});
    for(uint32_t i = 0; i < shape.getSize(); i++) {
    uint32_t dim_rem = input->getSize();
 constint* val = shape->read<int>(0, 0);
    for(uint32_t i = 0; i < shape->getSize(); i++) {
        if(val[i] == -1) {
            if(infer_index == -1) {
                infer_index = i;
    if(dim_rem != 1) ERR_EXIT("supplied shape does not match up to input");


    T* input_ptr = input.getPointer({});
 constT* input_ptr = input->read<T>(0, 0);
    //check if the output dim is valid
    if(output.getSize() > 0 && dim == output.getShape()) {
    if(output && output->getSize() > 0 && dim == output->getShape()) {
        //copy
        T* output_ptr = output.getPointer({});
        std::memcpy(output_ptr, input_ptr, (std::size_t) input.getSize_in_bytes());
    } else if(output.getSize() > 0 && dim != output.getShape()) {
        T* output_ptr = output->write<T>(0, 0);
        std::memcpy(output_ptr, input_ptr, (std::size_t) input->getSize_in_bytes());
    } else if(output && output->getSize() > 0 && dim != output->getShape()) {
        ERR_EXIT("output tensor dimension mismatches supplied shape")
    } else {
        //construct a new tensor and copy
        Tensor<T> tmp(dim);
        T* output_ptr = tmp.getPointer({});
        std::memcpy(output_ptr, input_ptr, (std::size_t) input.getSize_in_bytes());
        output = tmp;
        output->resize<T>(dim);
        T* output_ptr = output->write<T>(0, 0);
        std::memcpy(output_ptr, input_ptr, (std::size_t) input->getSize_in_bytes());
    }

 }
 class ReshapeOp : public Operator {
  public:
    ReshapeOp() {
      n_inputs = 2;
      n_outputs = 1;
    }

    virtual void compute() override {
      reshape<float>(inputs[0], inputs[1], outputs[0]);
    }
 };

 #endif  //UTENSOR_ARRAY_OPS
 #endif  //UTENSOR_ARRAY_OPS
diff --git a/ArrayTests.hpp b/ArrayTests.hpp
 #include "ArrayOps.hpp"
 #include "test.hpp"
 #include "tensorIdxImporter.hpp"
 #include "context.hpp"
 #include "tensor.hpp"

 class ArrayOpsTest : public Test {
        TensorIdxImporter t_import;
        Context ctx;
 public:
    void quantize_v2Test(void) {
        testStart("quantize_v2");
        TensorIdxImporter t_import;

        //reference inputs  /Users/neitan01/Documents/mbed/uTensor.git/TESTS/scripts/PRE-GEN/qA
 Tensor<float> b = t_import.float_import ("/fs/testData/qB/in/Cast_1_0.idx");
 Tensor<float> b_min = t_import.float_import("/fs/testData/qB/in/Min_1_0.idx");
 Tensor<float> b_max = t_import.float_import("/fs/testData/qB/in/Max_1_0.idx");
 S_TENSOR b_q_ref =ctx.addCached(hold(t_import.float_import ("/fs/testData/qB/in/Cast_1_0.idx")), "b_q_ref");
 S_TENSOR b_min_q_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/in/Min_1_0.idx")), "b_min_q_ref");
 S_TENSOR b_max_q_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/in/Max_1_0.idx")), "b_max_q_ref");

        //reference outputs
 Tensor<unsigned char> b_q_ref =t_import.ubyte_import("/fs/testData/qB/out/qB_0.idx");
 Tensor<float> b_min_q_ref = t_import.float_import("/fs/testData/qB/out/qB_1.idx");
 Tensor<float> b_max_q_ref = t_import.float_import("/fs/testData/qB/out/qb_2.idx");
 S_TENSOR ref_b_q = ctx.addCached(hold(t_import.ubyte_import("/fs/testData/qB/out/qB_0.idx")), "ref_b_q");
 S_TENSOR ref_b_min_q =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/out/qB_1.idx")), "ref_b_min_q");
 S_TENSOR ref_b_max_q =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/out/qb_2.idx")), "ref_b_max_q");

 Tensor<unsigned char> b_q(b_q_ref.getShape());
 Tensor<float> b_min_q(b_min_q_ref.getShape());
 Tensor<float> b_max_q(b_max_q_ref.getShape());
 S_TENSOR out_b_q = ctx.addCached(hold(new RamTensor<unsigned char>(b_q_ref->getShape())), "b_q");
 S_TENSOR out_b_min_q = ctx.addCached(hold(new RamTensor<float>(b_min_q_ref->getShape())), "b_min_q");
 S_TENSOR out_b_max_q = ctx.addCached(hold(new RamTensor<float>(b_max_q_ref->getShape())), "b_max_q");

        //Implementation goes here
        timer_start();
        QuantizeV2(b, b_min, b_max, b_q, b_min_q, b_max_q);
        ctx.push_static(hold(new QuantizeV2Op()), "QuantizeV2Op", {"b_q_ref", "b_min_q_ref", "b_max_q_ref"}, {"b_q", "b_min_q", "b_max_q"});
        ctx.eval();
        timer_stop();

        // printf("refMin is : %f \r\n", *(b_min_q_ref.getPointer({0})));
        // printf("outMin is : %f \r\n", *(b_min_q.getPointer({0})));
        // printf("diff : output(%f), outMin(%f), outMax(%f)\r\n",
        //  meanPercentErr(b_q_ref, b_q), meanPercentErr(b_min_q_ref, b_min_q), meanPercentErr(b_max_q_ref, b_max_q));

        double result = meanPercentErr(b_q_ref, b_q) + meanPercentErr(b_min_q_ref, b_min_q) + meanPercentErr(b_max_q_ref, b_max_q);
        double result = meanPercentErr<unsigned char>(ref_b_q.get(), out_b_q.get()) + meanPercentErr<float>(ref_b_min_q.get(), out_b_min_q.get()) + meanPercentErr<float>(ref_b_max_q.get(), out_b_max_q.get());
        //passed(result < 0.0001);
        passed(result == 0);
    }

    void dequantizeTest(void) {
        testStart("dequantize");
        TensorIdxImporter t_import;

        //reference inputs
 Tensor<unsigned char>a = t_import.ubyte_import("/fs/testData/deQ/in/rQ_0.idx");
 Tensor<float> a_min = t_import.float_import("/fs/testData/deQ/in/rQ_1.idx");
 Tensor<float> a_max = t_import.float_import("/fs/testData/deQ/in/rQ_2.idx");
 S_TENSORa =ctx.addCached(hold(t_import.ubyte_import("/fs/testData/deQ/in/rQ_0.idx")), "a");
 S_TENSOR a_min =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/in/rQ_1.idx")), "a_min");
 S_TENSOR a_max =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/in/rQ_2.idx")), "a_max");

        //reference outputs
 Tensor<float> out_ref = t_import.float_import("/fs/testData/deQ/out/deQ_0.idx");
 S_TENSOR out_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/out/deQ_0.idx")), "out_ref");

        //modify the checks below:
 Tensor<float> out(out_ref.getShape());
 S_TENSOR out = ctx.addCached(hold(new RamTensor<float>(out_ref->getShape())), "out");

        timer_start();
        dequantize(a, a_min, a_max, out);
        ctx.push_static(hold(new DequantizeOp()), "DequantizeOp", {"a", "a_min", "a_max"}, {"out"});
        ctx.eval();
        timer_stop();

        double result = meanPercentErr(out_ref, out);
        double result = meanPercentErr<float>(out.get(), out_ref.get());
        //passed(result < 0.0001);
        passed(result == 0);
    }
        TensorIdxImporter t_import;

        //reference inputs
 Tensor<float> ref_a = t_import.float_import("/fs/testData/ref_reshape/in/Const_0.idx");
 Tensor<int> ref_dim = t_import.int_import("/fs/testData/ref_reshape/in/Const_1_0.idx");
 S_TENSOR ref_a =ctx.addCached(hold(t_import.float_import("/fs/testData/ref_reshape/in/Const_0.idx")), "ref_a");
 S_TENSOR ref_dim =ctx.addCached(hold(t_import.int_import("/fs/testData/ref_reshape/in/Const_1_0.idx")), "ref_dim");

        //reference outputs
 Tensor<float> out_ref = t_import.float_import("/fs/testData/ref_reshape/out/ref_reshape_0.idx");
 S_TENSOR out_ref_2 =ctx.addCached(hold(t_import.float_import("/fs/testData/ref_reshape/out/ref_reshape_0.idx")), "out_ref_2");

        //modify the checks below:
        Tensor<float> out(out_ref.getShape());
        S_TENSOR out_2 = ctx.addCached(hold(new RamTensor<float>(out_ref_2->getShape())), "out_2");


        timer_start();
        reshape(ref_a, ref_dim, out);
        ctx.push_static(hold(new ReshapeOp()), "ReshapeOp", {"ref_a", "ref_dim"}, {"out_2"});
        ctx.eval();
        timer_stop();

        double result = meanPercentErr(out_ref, out);
        double result = meanPercentErr<float>(out_2.get(), out_ref_2.get());
        //passed(result < 0.0001);
        passed(result == 0);
    }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -36,3 +36,6 @@

		#Project generated test files
		TESTS/scripts/testData

		#Vim stuff
		*.swp
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5,36 +5,47 @@
		#include <math.h>
		#include "uTensor_util.hpp"
		#include "quantization_utils.hpp"
		#include "uTensorBase.hpp"

		//T = inferred
		//mode = MIN_FIRST
		//name = unspecified
		template <typename T>
		void QuantizeV2(Tensor<float> input,Tensor<float> _min_range,Tensor<float> _max_range,
		Tensor<T> output,Tensor<float> output_min,Tensor<float> output_max) {
		void QuantizeV2(S_TENSOR input,S_TENSOR _min_range,S_TENSOR _max_range,
		S_TENSOR output,S_TENSOR output_min,S_TENSOR output_max) {

		float input_min_range = *(_min_range.getPointer({0}));
		float input_max_range = *(_max_range.getPointer({0}));
		float input_min_range = *(_min_range->read<float>(0, 0));
		float input_max_range = *(_max_range->read<float>(0, 0));

		if(input_max_range < input_min_range) ERR_EXIT("input_max_range must be larger than input_min_range.");

		float min_range = std::min(0.0f, input_min_range);
		const float epsilon = std::max(1.0f, std::max(fabsf(input_min_range),
		fabsf(input_max_range))) / 100.0f;
		std::vector<uint32_t> v;

		std::vector<uint32_t> org = input->getShape();
		for (int i = org.size() - 1; i >= 0; i--) {
		v.push_back(org[i]);
		}

		if(output && output->getSize() == 0) {
		output->resize<T>(v);
		}

		float max_range = std::max(input_max_range, min_range + epsilon);
		max_range = std::max(0.0f, max_range);

		FloatToQuantizedStruct<T> f2q(min_range, max_range);

		//quantization_utils.h:149
		float* input_ptr = input.getPointer({});
		T* output_ptr = output.getPointer({});
		float* output_min_ptr = output_min.getPointer({0});
		float* output_max_ptr = output_max.getPointer({0});
		constfloat* input_ptr = input->read<float>(0, 0);
		T* output_ptr = output->write<T>(0, 0);
		float* output_min_ptr = output_min->write<float>(0, 0);
		float* output_max_ptr = output_max->write<float>(0, 0);

		///NT: need error checking at some point...
		for(uint32_t i = 0; i < input.getSize(); i++) {
		for(uint32_t i = 0; i < input->getSize(); i++) {
		float val = std::round(input_ptr[i] * f2q.range_scale);
		val -= f2q.range_min_scaled - f2q.lowest_quantized();
		val = std::max(val, f2q.lower_bound_float());
Expand All		@@ -48,29 +59,55 @@ void QuantizeV2(Tensor<float> input, Tensor<float> _min_range, Tensor<float> _ma

		}

		class QuantizeV2Op : public Operator {
		public:
		QuantizeV2Op() {
		n_inputs = 3;
		n_outputs = 3;
		}

		virtual void compute() override {
		QuantizeV2<unsigned char>(inputs[0], inputs[1], inputs[2],
		outputs[0], outputs[1], outputs[2]);
		}
		};

		//mode = MIN_FIRST
		//name = unspecified
		//dequantize_op.cc: 87
		template <typename T>
		void dequantize(Tensor<T> input,Tensor<float> min_range,Tensor<float> max_range,Tensor<float> &output) {
		float min = *(min_range.getPointer({0}));
		float max = *(max_range.getPointer({0}));
		void dequantize(S_TENSOR input,S_TENSOR min_range,S_TENSOR max_range,S_TENSORoutput) {
		float min = *(min_range->read<float>(0, 0));
		float max = *(max_range->read<float>(0, 0));
		//auto tensor allocation
		Shape out_shape;
		tensorChkAlloc(output,input.getShape());
		output->resize<float>(input->getShape());

		T* input_ptr = input.getPointer({});
		float* output_ptr = output.getPointer({});
		constT* input_ptr = input->read<T>(0, 0);
		float* output_ptr = output->write<float>(0, 0);

		//quantization_utils.h: 771
		QuantizedToFloatStruct<T> q2f(min, max);

		//quantization_utils.h: 141
		for(uint32_t i = 0; i < input.getSize(); i++) {
		for(uint32_t i = 0; i < input->getSize(); i++) {
		float val = static_cast<float>(input_ptr[i]);
		output_ptr[i] = ((q2f.range_min_rounded - q2f.lowest_quantized() * q2f.range_scale) + \
		val * q2f.range_scale);
		}
		}
		class DequantizeOp : public Operator {
		public:
		DequantizeOp() {
		n_inputs = 3;
		n_outputs = 1;
		}

		virtual void compute() override {
		dequantize<unsigned char>(inputs[0], inputs[1], inputs[2],
		outputs[0]);
		}
		};
		/*
		number_of_steps = 1 << (# of bits in T)
		range_adjust = number_of_steps / (number_of_steps - 1)
Expand All		@@ -84,7 +121,6 @@ void dequantize(Tensor<T> input, Tensor<float> min_range, Tensor<float> max_rang
		// output_ptr[i] = QuantizedToFloat(input_ptr[i], min, max);
		// }

		}

		//Pre:
		//output.getShape == shape, or
Expand All		@@ -94,14 +130,27 @@ void dequantize(Tensor<T> input, Tensor<float> min_range, Tensor<float> max_rang

		///NT: This Op hasn't been tested extensively. We will have to increase the test-coverage for this function.
		template <typename T>
		void reshape(Tensor<T> input,Tensor<int> shape,Tensor<T> &output) {
		void reshape(S_TENSOR input,S_TENSOR shape,S_TENSORoutput) {
		Shape dim;
		uint32_t t = input->getShape().size();
		if (t == 0) {
		t = 1;
		}

		shape->resize<int>({t});

		if (t == 1) {
		shape->write<int>(0, 0)[0] = -1;
		} else {
		shape->write<int>(0, 0)[0] = input->getSize();
		shape->write<int>(0, 0)[1] = -1;
		}

		//validating and inferring dimensions
		int infer_index = -1;
		uint32_t dim_rem = input.getSize();
		int* val = shape.getPointer({});
		for(uint32_t i = 0; i < shape.getSize(); i++) {
		uint32_t dim_rem = input->getSize();
		constint* val = shape->read<int>(0, 0);
		for(uint32_t i = 0; i < shape->getSize(); i++) {
		if(val[i] == -1) {
		if(infer_index == -1) {
		infer_index = i;
Expand All		@@ -123,22 +172,32 @@ void reshape(Tensor<T> input, Tensor<int> shape, Tensor<T> &output) {
		if(dim_rem != 1) ERR_EXIT("supplied shape does not match up to input");


		T* input_ptr = input.getPointer({});
		constT* input_ptr = input->read<T>(0, 0);
		//check if the output dim is valid
		if(output.getSize() > 0 && dim == output.getShape()) {
		if(output && output->getSize() > 0 && dim == output->getShape()) {
		//copy
		T* output_ptr = output.getPointer({});
		std::memcpy(output_ptr, input_ptr, (std::size_t) input.getSize_in_bytes());
		} else if(output.getSize() > 0 && dim != output.getShape()) {
		T* output_ptr = output->write<T>(0, 0);
		std::memcpy(output_ptr, input_ptr, (std::size_t) input->getSize_in_bytes());
		} else if(output && output->getSize() > 0 && dim != output->getShape()) {
		ERR_EXIT("output tensor dimension mismatches supplied shape")
		} else {
		//construct a new tensor and copy
		Tensor<T> tmp(dim);
		T* output_ptr = tmp.getPointer({});
		std::memcpy(output_ptr, input_ptr, (std::size_t) input.getSize_in_bytes());
		output = tmp;
		output->resize<T>(dim);
		T* output_ptr = output->write<T>(0, 0);
		std::memcpy(output_ptr, input_ptr, (std::size_t) input->getSize_in_bytes());
		}

		}
		class ReshapeOp : public Operator {
		public:
		ReshapeOp() {
		n_inputs = 2;
		n_outputs = 1;
		}

		virtual void compute() override {
		reshape<float>(inputs[0], inputs[1], outputs[0]);
		}
		};

		#endif //UTENSOR_ARRAY_OPS
		#endif //UTENSOR_ARRAY_OPS
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,62 +4,62 @@
		#include "ArrayOps.hpp"
		#include "test.hpp"
		#include "tensorIdxImporter.hpp"
		#include "context.hpp"
		#include "tensor.hpp"

		class ArrayOpsTest : public Test {
		TensorIdxImporter t_import;
		Context ctx;
		public:
		void quantize_v2Test(void) {
		testStart("quantize_v2");
		TensorIdxImporter t_import;

		//reference inputs /Users/neitan01/Documents/mbed/uTensor.git/TESTS/scripts/PRE-GEN/qA
		Tensor<float> b = t_import.float_import ("/fs/testData/qB/in/Cast_1_0.idx");
		Tensor<float> b_min = t_import.float_import("/fs/testData/qB/in/Min_1_0.idx");
		Tensor<float> b_max = t_import.float_import("/fs/testData/qB/in/Max_1_0.idx");
		S_TENSOR b_q_ref =ctx.addCached(hold(t_import.float_import ("/fs/testData/qB/in/Cast_1_0.idx")), "b_q_ref");
		S_TENSOR b_min_q_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/in/Min_1_0.idx")), "b_min_q_ref");
		S_TENSOR b_max_q_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/in/Max_1_0.idx")), "b_max_q_ref");

		//reference outputs
		Tensor<unsigned char> b_q_ref =t_import.ubyte_import("/fs/testData/qB/out/qB_0.idx");
		Tensor<float> b_min_q_ref = t_import.float_import("/fs/testData/qB/out/qB_1.idx");
		Tensor<float> b_max_q_ref = t_import.float_import("/fs/testData/qB/out/qb_2.idx");
		S_TENSOR ref_b_q = ctx.addCached(hold(t_import.ubyte_import("/fs/testData/qB/out/qB_0.idx")), "ref_b_q");
		S_TENSOR ref_b_min_q =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/out/qB_1.idx")), "ref_b_min_q");
		S_TENSOR ref_b_max_q =ctx.addCached(hold(t_import.float_import("/fs/testData/qB/out/qb_2.idx")), "ref_b_max_q");

		Tensor<unsigned char> b_q(b_q_ref.getShape());
		Tensor<float> b_min_q(b_min_q_ref.getShape());
		Tensor<float> b_max_q(b_max_q_ref.getShape());
		S_TENSOR out_b_q = ctx.addCached(hold(new RamTensor<unsigned char>(b_q_ref->getShape())), "b_q");
		S_TENSOR out_b_min_q = ctx.addCached(hold(new RamTensor<float>(b_min_q_ref->getShape())), "b_min_q");
		S_TENSOR out_b_max_q = ctx.addCached(hold(new RamTensor<float>(b_max_q_ref->getShape())), "b_max_q");

		//Implementation goes here
		timer_start();
		QuantizeV2(b, b_min, b_max, b_q, b_min_q, b_max_q);
		ctx.push_static(hold(new QuantizeV2Op()), "QuantizeV2Op", {"b_q_ref", "b_min_q_ref", "b_max_q_ref"}, {"b_q", "b_min_q", "b_max_q"});
		ctx.eval();
		timer_stop();

		// printf("refMin is : %f \r\n", *(b_min_q_ref.getPointer({0})));
		// printf("outMin is : %f \r\n", *(b_min_q.getPointer({0})));
		// printf("diff : output(%f), outMin(%f), outMax(%f)\r\n",
		// meanPercentErr(b_q_ref, b_q), meanPercentErr(b_min_q_ref, b_min_q), meanPercentErr(b_max_q_ref, b_max_q));

		double result = meanPercentErr(b_q_ref, b_q) + meanPercentErr(b_min_q_ref, b_min_q) + meanPercentErr(b_max_q_ref, b_max_q);
		double result = meanPercentErr<unsigned char>(ref_b_q.get(), out_b_q.get()) + meanPercentErr<float>(ref_b_min_q.get(), out_b_min_q.get()) + meanPercentErr<float>(ref_b_max_q.get(), out_b_max_q.get());
		//passed(result < 0.0001);
		passed(result == 0);
		}

		void dequantizeTest(void) {
		testStart("dequantize");
		TensorIdxImporter t_import;

		//reference inputs
		Tensor<unsigned char>a = t_import.ubyte_import("/fs/testData/deQ/in/rQ_0.idx");
		Tensor<float> a_min = t_import.float_import("/fs/testData/deQ/in/rQ_1.idx");
		Tensor<float> a_max = t_import.float_import("/fs/testData/deQ/in/rQ_2.idx");
		S_TENSORa =ctx.addCached(hold(t_import.ubyte_import("/fs/testData/deQ/in/rQ_0.idx")), "a");
		S_TENSOR a_min =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/in/rQ_1.idx")), "a_min");
		S_TENSOR a_max =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/in/rQ_2.idx")), "a_max");

		//reference outputs
		Tensor<float> out_ref = t_import.float_import("/fs/testData/deQ/out/deQ_0.idx");
		S_TENSOR out_ref =ctx.addCached(hold(t_import.float_import("/fs/testData/deQ/out/deQ_0.idx")), "out_ref");

		//modify the checks below:
		Tensor<float> out(out_ref.getShape());
		S_TENSOR out = ctx.addCached(hold(new RamTensor<float>(out_ref->getShape())), "out");

		timer_start();
		dequantize(a, a_min, a_max, out);
		ctx.push_static(hold(new DequantizeOp()), "DequantizeOp", {"a", "a_min", "a_max"}, {"out"});
		ctx.eval();
		timer_stop();

		double result = meanPercentErr(out_ref, out);
		double result = meanPercentErr<float>(out.get(), out_ref.get());
		//passed(result < 0.0001);
		passed(result == 0);
		}
Expand All		@@ -69,20 +69,22 @@ class ArrayOpsTest : public Test {
		TensorIdxImporter t_import;

		//reference inputs
		Tensor<float> ref_a = t_import.float_import("/fs/testData/ref_reshape/in/Const_0.idx");
		Tensor<int> ref_dim = t_import.int_import("/fs/testData/ref_reshape/in/Const_1_0.idx");
		S_TENSOR ref_a =ctx.addCached(hold(t_import.float_import("/fs/testData/ref_reshape/in/Const_0.idx")), "ref_a");
		S_TENSOR ref_dim =ctx.addCached(hold(t_import.int_import("/fs/testData/ref_reshape/in/Const_1_0.idx")), "ref_dim");

		//reference outputs
		Tensor<float> out_ref = t_import.float_import("/fs/testData/ref_reshape/out/ref_reshape_0.idx");
		S_TENSOR out_ref_2 =ctx.addCached(hold(t_import.float_import("/fs/testData/ref_reshape/out/ref_reshape_0.idx")), "out_ref_2");

		//modify the checks below:
		Tensor<float> out(out_ref.getShape());
		S_TENSOR out_2 = ctx.addCached(hold(new RamTensor<float>(out_ref_2->getShape())), "out_2");


		timer_start();
		reshape(ref_a, ref_dim, out);
		ctx.push_static(hold(new ReshapeOp()), "ReshapeOp", {"ref_a", "ref_dim"}, {"out_2"});
		ctx.eval();
		timer_stop();

		double result = meanPercentErr(out_ref, out);
		double result = meanPercentErr<float>(out_2.get(), out_ref_2.get());
		//passed(result < 0.0001);
		passed(result == 0);
		}
Expand Down