OHE doc, Activation functions+doc

CMakeLists.txt

@@ -60,4 +60,6 @@ add_library(slowmokit
         src/slowmokit/methods/metrics/recall.hpp
         src/slowmokit/methods/metrics/recall.cpp
         src/slowmokit/methods/metrics/mean_squared_error.hpp
-        src/slowmokit/methods/metrics/mean_squared_error.cpp)
+        src/slowmokit/methods/metrics/mean_squared_error.cpp
+        src/slowmokit/methods/activation_functions.cpp
+        src/slowmokit/methods/activation_functions.hpp)

docs/methods/activation_functions.md

@@ -0,0 +1,110 @@
+# Activation Functions 
+
+Sigmoid-It is computationally expensive, causes vanishing gradient problem and not zero-centred. This method is generally used for binary classification problems.
+
+tanh- The Tanh activation function is a hyperbolic tangent sigmoid function that has a range of -1 to 1. It is often used in deep learning models for its ability to model nonlinear boundaries
+
+tan-1h-The ArcTan function is a sigmoid function to model accelerating and decelerating outputs but with useful output ranges.This activation function maps the input values in the range (−π/2,π/2). Its derivative converges quadratically against 0 for large input values.
+
+ReLU-This The ReLU activation function returns 0 if the input value to the function is less than 0 but for any positive input, the output is the same as the input. It is also continuous but non-differentiable at 0 and at values less than 0 because its derivative is 0 for any negative input.
+
+leakyReLU- With Leaky ReLU there is a small negative slope so instead of that firing at all, for large gradients, our neurons do output some value and that makes our layer much more optimized too.
+
+softmax-The softmax is a more generalised form of the sigmoid. It is used in multi-class classification problems. Similar to sigmoid, it produces values in the range of 0–1 therefore it is used as the final layer in classification models.
+
+binaryStep-The Step activation function is used in the perceptron network. This is usually used in single-layer networks to convert to an output that is binary (0 or 1).These are called Binary Step Function.
+
+
+The following function definitions are defined for a single variable for making it comprehendible and are implemented for a vector of 'double' values in the original code.
+## Parameters
+
+| Name         | Definition                                 | Type         |
+|--------------|--------------------------------------------|--------------|
+|   x          |      double value on which the function is applied.                                      | `double` |
+
+
+## Functions
+
+| Name                                   | Definition                                    | Return value  |
+|----------------------------------------|-----------------------------------------------|---------------|
+|sigmoid(x)|             1 / (1 + e^(-x)) |                    `double` |
+|tanh(x)|                (e^x - e^(-x)) / (e^x + e^(-x)) |     `double` |
+|arctan(x)|              the inverse of tan(x) |               `double` |
+|ReLU(x)|                max(0, x) |                           `double` |
+|leakyReLU(x)|           max(αx, x),α=0.1 |                    `double` |
+|binaryStep(x)|          0, if x < 0
+                         1, if x ≥ 0 |                         `double` |
+|softmax(x)|             e^(x_i) / Σ_j e^(x_j)   |             `double` |
+
+
+## Example
+
+```cpp
+int main(){
+                      //sigmoid example    
+std::vector<double> x = {-1,0,1};
+std::vector<double> y = sigmoid(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+
+}
+
+                      //tanh example
+std::vector<double> x = {-1,0,1};
+std::vector<double> y = tanh(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+
+}
+
+                      //arctan example
+std::vector<double> x = {-1,0,1};
+std::vector<double> y = arctan(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+
+}
+                      //ReLU example
+std::vector<double> x = {1, 2, 3};
+std::vector<double> y = ReLU(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+
+}
+
+                       //leakyReLU example
+std::vector<double> x = {1, 2, 3};
+std::vector<double> y = leakyReLU(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+}
+
+                       //binaryStep example
+std::vector<double> x = {1, 2, 3};
+std::vector<double> y = binaryStep(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+}
+
+                        //softmax example
+std::vector<double> x = {1, 2, 3};
+std::vector<double> y= softmax(x);
+ for (int i = 0; i < y.size(); i++) {
+        std::cout << y[i] << " ";
+    }
+    return 0;
+
+}
+```

docs/methods/preprocessing/one_hot_encoder.md

@@ -0,0 +1,36 @@
+# One Hot Encoder
+
+One hot encoding is a technique to represent categorical variables as numerical values.Each unique value of a categorical variable is assigned a binary code, where a "1" in the code represents the presence of that value and a "0" represents its absence.
+
+One hot encoding makes our training data more useful and expressive, and it can be rescaled easily.
+
+
+## Parameters
+
+| Name         | Definition                                 | Type         |
+|--------------|--------------------------------------------|--------------|
+|   data       | The data that has to be encoded is passed as the data parameter in the oneHotEncoder function. | `vector<string>` |
+|   nClasses      | This parameter is an integer that specifies the number of classes or categories in the input data. | `int` |
+
+## Methods
+
+| Name                                   | Definition                                    | Return value  |
+|----------------------------------------|-----------------------------------------------|---------------|
+| `oneHotEncoder(vector<T> data, nClasses)` | To encode the data into numerical values. | `vector<vector<int>>` |
+
+## Example
+
+```cpp
+int main() {
+ std::vector<std::string> data = {"apples", "banana", "mango", "pear", "mango","apples","pear"};
+ int nClasses = 4;
+  std::vector<std::vector<int>> oneHotEncodedData = oneHotEncoder(data, nClasses);
+  for (const auto &row : oneHotEncodedData) {
+    for (const auto &column : row) {
+      std::cout << column << " ";
+    }
+    std::cout << std::endl;
+  }
+  return 0;
+}
+```

examples/activation_functions_eg.cpp

@@ -0,0 +1,67 @@
+//int main(){
+                      //sigmoid example    
+//std::vector<double> x = {-1,0,1};
+//std::vector<double> y = sigmoid(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+
+//}
+
+                      //tanh example
+//std::vector<double> x = {-1,0,1};
+//std::vector<double> y = tanh(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+
+//}
+
+                      //arctan example
+//std::vector<double> x = {-1,0,1};
+//std::vector<double> y = arctan(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+
+//}
+                      //ReLU example
+//std::vector<double> x = {1, 2, 3};
+//std::vector<double> y = ReLU(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+
+//}
+
+                       //leakyReLU example
+//std::vector<double> x = {1, 2, 3};
+//std::vector<double> y = leakyReLU(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+//}
+
+                       //binaryStep example
+//std::vector<double> x = {1, 2, 3};
+//std::vector<double> y = binaryStep(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+//}
+
+                        //softmax example
+//std::vector<double> x = {1, 2, 3};
+//std::vector<double> y = softmax(x);
+// for (int i = 0; i < y.size(); i++) {
+//        std::cout << y[i] << " ";
+//    }
+//    return 0;
+
+//}

src/slowmokit/methods/activation_functions.cpp

@@ -0,0 +1,130 @@
+/**
+ * @file methods/activation_functions.cpp
+ *
+ * Implementation of activation functions
+ */
+#include "activation_functions.hpp"
+template<class T>
+// sigmoid
+std::vector<double> sigmoid(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] = 1 / (1 + exp(-x[i]));
+  }
+  return y;
+}
+// ReLU
+std::vector<double> ReLU(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    if (x[i] > 0.0)
+    {
+      y[i] = x[i];
+    }
+    else
+    {
+      y[i] = 0.0;
+    }
+  }
+  return y;
+}
+// tanh
+std::vector<double> tanh(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] =
+        (std::exp(x[i]) - std::exp(-x[i])) / (std::exp(x[i]) + std::exp(-x[i]));
+  }
+  return y;
+}
+// arctan
+std::vector<double> arctan(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] = atan(x[i]);
+  }
+  return y;
+}
+
+// softmax
+std::vector<double> softmax(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  double sum = 0;
+  for (double value : x)
+  {
+    sum += std::exp(value);
+  }
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] = std::exp(x[i]) / sum;
+  }
+  return y;
+}
+// binarystep
+std::vector<double> binaryStep(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    if (x[i] >= 0)
+    {
+      y[i] = 1;
+    } // assuming threshold value to be 0 here
+    else
+    {
+      y[i] = 0;
+    }
+  }
+  return y;
+}
+// leakyReLU
+std::vector<double> leakyReLU(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  double alpha = 0.1;
+  for (int i = 0; i < x.size(); i++)
+  {
+    if (x[i] >= 0)
+    {
+      y[i] = x[i];
+    }
+    else
+    {
+      y[i] = alpha * x[i]; // alpha=0.1
+    };
+  }
+  return y;
+}
+// binaryToBipolar Conversion
+// x= binary numbers entered by the user
+// y= bipolar numbers to be produced as output
+std::vector<double> binaryToBipolar(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] = 2 * x[i] - 1;
+  }
+  return y;
+}
+// bipolarToBinary Conversion
+// x= bipolar numbers entered by the user
+// y= binary numbers to be produced as output
+std::vector<double> bipolarToBinary(const std::vector<double> &x)
+{
+  std::vector<double> y(x.size());
+  for (int i = 0; i < x.size(); i++)
+  {
+    y[i] = (x[i] + 1) / 2;
+  }
+  return y;
+}