one_hot tensor_op added (#23)

Author: czgdp1807

bnn/core/tensor_ops.hpp

@@ -113,6 +113,34 @@ namespace bnn
         divide
         (TensorCPU<data_type>* x, data_type divisor);
 
+        /*
+        * Returns a one hot tensor with a new axis appended
+        * in its shape.
+        *
+        * @tparam data_type Data type of the elements
+        *     supported by C++.
+        * @param x Tensor<data_type>* Tensor whose
+        *     elements are to be converted to one
+        *     hot notation.
+        * @param on_value data_type The value which
+        *     is to be used for filling in the one
+        *     hot tensor when the value in the original
+        *     tensor matches with the index in the
+        *     range [0, depth) for the new axis.
+        * @param off_value data_type The value which
+        *     is to be used for filling in the one
+        *     hot tensor when the value in the original
+        *     tensor doesn't match with the index in the
+        *     range [0, depth) for the new axis.
+        * @param depth unsigned The size of the axis which
+        *     is to be appended.
+        */
+        template <class data_type>
+        TensorCPU<data_type>*
+        one_hot
+        (TensorCPU<data_type>* x, data_type on_value,
+         data_type off_value, unsigned depth);
+
     }
 }
 

bnn/core/tensor_ops_impl.cpp

@@ -207,8 +207,6 @@ namespace bnn
         template <class data_type>
         struct DivideArgs: ScalarArgs<data_type>
         {
-            data_type val;
-
             data_type* zd;
         };
 
@@ -393,6 +391,52 @@ namespace bnn
             return z;
         }
 
+        template <class data_type>
+        struct OneHot: UnaryArgs<data_type>
+        {
+            data_type* zd;
+
+            data_type on, off;
+
+            unsigned depth;
+
+        };
+
+        template <class data_type>
+        void
+        _one_hot_job
+        (Args<data_type>* _args, unsigned start,
+         unsigned end)
+        {
+            OneHot<data_type>* args = reinterpret_cast<OneHot<data_type>*>(_args);
+            unsigned k = start;
+            for(unsigned i = start; i < end; i++)
+            {
+                for(unsigned j = 0; j < args->depth; j++)
+                {
+                    args->zd[k] = j == args->xd[i] ? args->on : args->off;
+                    k++;
+                }
+            }
+        }
+
+        template <class data_type>
+        TensorCPU<data_type>*
+        one_hot
+        (TensorCPU<data_type>* x, data_type on_value,
+         data_type off_value, unsigned depth)
+        {
+            vector<unsigned> shape
+            (x->get_shape(), x->get_shape() + x->get_ndims());
+            shape.push_back(depth);
+            TensorCPU<data_type>* z = new TensorCPU<data_type>(shape);
+            OneHot<data_type> args;
+            args.zd = z->get_data_pointer();
+            args.on = on_value, args.off = off_value, args.depth = depth;
+            op(x, &args, &_one_hot_job<data_type>);
+            return z;
+        }
+
         #include "bnn/templates/core/tensor_ops.hpp"
 
     }

bnn/templates/core/tensor_ops.hpp

@@ -85,5 +85,17 @@ template TensorCPU<unsigned long long>* divide<unsigned long long>(TensorCPU<uns
 template TensorCPU<float>* divide<float>(TensorCPU<float>* x, float divisor);
 template TensorCPU<double>* divide<double>(TensorCPU<double>* x, double divisor);
 template TensorCPU<long double>* divide<long double>(TensorCPU<long double>* x, long double divisor);
+template TensorCPU<bool>* one_hot<bool>(TensorCPU<bool>* x, bool on_value, bool off_value, unsigned depth);
+template TensorCPU<short>* one_hot<short>(TensorCPU<short>* x, short on_value, short off_value, unsigned depth);
+template TensorCPU<unsigned short>* one_hot<unsigned short>(TensorCPU<unsigned short>* x, unsigned short on_value, unsigned short off_value, unsigned depth);
+template TensorCPU<int>* one_hot<int>(TensorCPU<int>* x, int on_value, int off_value, unsigned depth);
+template TensorCPU<unsigned int>* one_hot<unsigned int>(TensorCPU<unsigned int>* x, unsigned int on_value, unsigned int off_value, unsigned depth);
+template TensorCPU<long>* one_hot<long>(TensorCPU<long>* x, long on_value, long off_value, unsigned depth);
+template TensorCPU<unsigned long>* one_hot<unsigned long>(TensorCPU<unsigned long>* x, unsigned long on_value, unsigned long off_value, unsigned depth);
+template TensorCPU<long long>* one_hot<long long>(TensorCPU<long long>* x, long long on_value, long long off_value, unsigned depth);
+template TensorCPU<unsigned long long>* one_hot<unsigned long long>(TensorCPU<unsigned long long>* x, unsigned long long on_value, unsigned long long off_value, unsigned depth);
+template TensorCPU<float>* one_hot<float>(TensorCPU<float>* x, float on_value, float off_value, unsigned depth);
+template TensorCPU<double>* one_hot<double>(TensorCPU<double>* x, double on_value, double off_value, unsigned depth);
+template TensorCPU<long double>* one_hot<long double>(TensorCPU<long double>* x, long double on_value, long double off_value, unsigned depth);
 
 #endif

bnn/tests/test_core.cpp

@@ -48,6 +48,27 @@ TEST(Core, TensorOpsDivide)
     EXPECT_EQ(z->at(0, 4, 8, 50), 2)<<"Expected quotient is 2.";
 }
 
+TEST(Core, TensorOpsOneHot)
+{
+    vector<unsigned> shape = {1000};
+    TensorCPU<unsigned>* labels = new TensorCPU<unsigned>(shape);
+    bnn::core::fill(labels, (unsigned)9);
+    for(unsigned i = 0; i < 9; i++)
+    {
+        labels->set(i, i);
+    }
+    TensorCPU<unsigned>* new_labels = one_hot(labels, (unsigned)1, (unsigned)0, (unsigned)10);
+    for(unsigned i = 0; i < 10; i++)
+    {
+        for(unsigned j = 0; j < 10; j++)
+        {
+            EXPECT_EQ(new_labels->at(i, j), labels->at(i) == j)
+            <<"Expected one hot value is "<<(labels->at(i) == j)
+            <<" for "<<i<<", "<<j;
+        }
+    }
+}
+
 TEST(Core, TensorCPU)
 {
     TensorCPU<float>* t_f = new TensorCPU<float>;