Add README

Author: loki-veera

README.md

@@ -0,0 +1,39 @@
+# Exercise Denoise Cosine
+The goal of this exercise is to implement a multilayer dense neuralnetwork from scratch using C++.
+Specifically, you will implement gradient descent and use it to learn a cosine function.
+- First, take a look and understand array datatype defined in `line 8` in `src/utils.cpp`.
+- Further now, code the linear algebra operations such as matrix multplication, addition, subtraction, hadamard (element-wise) product, matrix elements sum, transpose, and matrix power (element-wise) in `src/utils.cpp`.
+- You can check your implementation of functions in `src/utils.cpp` by running tests with following commands
+```bash
+cd <exercise_folder>/tests
+g++ -o test_utils_executable test_utils.cpp
+./test_utils_executable
+```
+- If you see no output by running the executable, this means the implementation is right.
+- Navigate to `src/mlutils.cpp` and code `sigmoid` activation function as first step.
+```math
+\sigma(x) = \frac{1}{1 + e^{-x}}
+```
+- In next step, given ground truth and predictions, compute Mean Square Error (MSE) in `cost` function as follows
+```math
+MSE = \frac{1}{2}\sum(y-h)^2
+```
+- Similarly you can test your implementation of `src/mlutils.cpp` by executing `test_mlutils.cpp`.
+- Navigate to `src/denoise_cosine.cpp` with the above custom datatype, declare $W_1, W_2, bias$ variables and intialise the weights using the corresponding initialisation function in `src/utils.cpp`. Similarly declare the gradient variables.
+- Code the forward pass in `network` function in `src/denoise_cosine.cpp` and call this forward pass in main function training followed by above implemented loss function.
+- As a next step, derive the gradients for each variable and implement in `compute_gradients` function in `src/mlutils.cpp`. Note: `compute_gradients` function needs the above declared gradient variables as arguments and they are pass by reference, so no return type is necessary. 
+- As a final training step implement the gradient descent step using the following formula.
+```math
+W_{new} = W_{old} - lr*\nabla W_{old}
+```
+- Finally compute the network predictions and assign it to `y_hat` variable. Now you can run the C++ program by runnig the following commands
+```bash
+cd <exercise_folder>/src
+g++ -o denoise_executable denoise_cosing.cpp
+./denoise_executable
+```
+- Finally, to check our cosine fit, you need to run the following commands
+```bash
+cd <exercise_folder>/src
+python plot.py
+```

requirements.txt

@@ -0,0 +1,2 @@
+numpy
+matplotlib

src/denoise_cos.png

@@ -7,42 +7,33 @@
 using namespace std;
 
 twod_array network(twod_array w1, twod_array w2, twod_array b, twod_array x){
-    twod_array h0 = sigmoid(matadd(matmul(w1, x), b));
-    twod_array h1 = matmul(w2, h0);
-    return h1;
+    // TODO: Implement forward pass
 }
 
 int main(){
+    int input_neurons = 200;
+    int output_neurons = 200;
+    int hidden_neurons = 10;
     double lr = 0.01;
     int epochs = 150;
+    
+    twod_array y_noise(input_neurons, vector<double>(1));
+    twod_array y(input_neurons, vector<double>(1));
+    read_cosine(y_noise, y);
+
     twod_array y_hat;
     double loss_val;
-    vector<double> gradients;
-    twod_array W1(10, vector<double>(200));
-    twod_array W2(200, vector<double>(10));
-    twod_array bias(10, vector<double>(1));
-    twod_array grad_w1(10, vector<double>(200)); 
-    twod_array grad_w2(200, vector<double>(10)); 
-    twod_array grad_bias(10, vector<double>(1)); 
-    twod_array y_noise(200, vector<double>(1));
-    twod_array y(200, vector<double>(1));
-
-    read_cosine(y_noise, y);
 
-    initialise_weights(W1);
-    initialise_weights(W2);
-    initialise_weights(bias);
+    // TODO: Declare and intialise parameters
+    // TODO: Declare gradients
 
     for(int epoch=0; epoch<epochs; epoch++){
-        y_hat = network(W1, W2, bias, y_noise);
-        loss_val = cost(y, y_hat);
-        compute_gradients(W2, W1, bias, y_noise, y, grad_w2, grad_w1, grad_bias);
-        W2 = matadd(W2, ele_product(ele_product(grad_w2, lr), -1.0));
-        W1 = matadd(W1, ele_product(ele_product(grad_w1, lr), -1.0));
-        bias = matadd(bias, ele_product(ele_product(grad_bias, lr), -1.0));
+        // TODO: Forward pass
+        // TODO: Compute cost and gradients
+        // TODO: Update parameters using SGD
         cout << "Epoch: " << epoch << " Loss: " << loss_val << endl;
     }
-    y_hat = network(W1, W2, bias, y_noise);
+    // TODO: Get network predictions on y_noise and assign to y_hat variable.
     write_cosine(y_hat);
     return 0;
 }

src/denoise_cosine.cpp

@@ -5,18 +5,13 @@
 using namespace std;
 
 twod_array sigmoid(twod_array matrix){
-    for (int i=0; i<matrix.size(); i++){
-        for (int j=0; j<matrix[0].size(); j++){
-            matrix[i][j] = 1 / (1 + exp(-1*matrix[i][j]));
-        }
-    }
+    // TODO: Implemet sigmoid activation.
     return matrix;
 }
 
 double cost(twod_array gt, twod_array h){
-    twod_array error = matpow(matsub(gt, h), 2);
-    double sum_val = matsum(error);
-    return 0.5 * sum_val;
+    //TODO: Compute mse loss
+    return 0.0;
 }
 
 void compute_gradients(twod_array w_2, twod_array w_1, twod_array bias, twod_array x, twod_array y,