Some changes on the files.

Author: dembasowfr

Makefile

@@ -1,8 +1,4 @@
-<<<<<<< HEAD
 
-
-=======
->>>>>>> 3fd407e (Run the project on windows Powershell)
 CC=g++ 
 CFLAGS= -std=gnu++11 -O2 -Iinclude -I/usr/include/python3.10
 LDFLAGS= -lpython3.10

README.md

@@ -7,10 +7,9 @@
 ## Code structure
   * filter.hpp defines a 3-D convolutinal kernel class with a bias term. It contains some helper functions to allocate memory to tensors and to normalize them.
   * Convolution.hpp defines a convolutional layer. One can set the stride and zero-padding of the filter in this. Also, dimensions of the output layer are calculated automatically.
-  * conv2d method takes as argument a 3-D data volume and a list of filters (one filter generates one activation map). For example, applying a 3 x 3 x 3 filter on a 512 x 512 x 3 image (with 1 zero padding and 1 stride) will generate an 2-D output layer of 512 x 512. See example (taken from course [cs231n](http://cs231n.stanford.edu/syllabus.html)).
-  ![One filter](./images/one_map.png)
+  * conv2d method takes as argument a 3-D data volume and a list of filters (one filter generates one activation map). For example, applying a 3 x 3 x 3 filter on a 300 x 300 x 3 image (with 1 zero padding and 1 stride) will generate an 2-D output layer of 300 x 300. 
   * List of filters would make the output layer. Shape of output layer as well as the data block is returned by the function conv2d.
-  ![Many filter](./images/multi_map.png)
+
   * main.cpp runs some example filters on a batch of 3 images. It generates 3 filters, one as an edge detector for each color channel (see push\_filter). Then defines
     a convolution layer with given params and applies the layer to each of the images. It then writes the output to a different file.
   *Inside helpers directory, we have make\_mats.py and load\_img.py that are used to generate images\-matrices and vice versa.
@@ -55,7 +54,7 @@ g++  -std=gnu++11 -O2 conv2d_layer.hpp -o conv2d_layer.o
 g++  -std=gnu++11 -O2 main.cpp -o main
 ```
 
-* List of images to use is in file make\_mats.py. In the demo it uses a batch of 3  512 \* 512 \* 3 (color) images.
+* List of images to use is in file make\_mats.py. In the demo it uses a batch of 3  300 \* 300 \* 3 (color) images.
 
 ```bash
 python3 make_mats.py img_mats/out.dat
@@ -78,9 +77,6 @@ python3 load_img.py img_mats/filter_out.dat out_mats
 You can checkout the image results in the out_mats directory. The output images are generated by applying a filter to the input images. 
 The filter is defined in filter.txt, which is the given kernel with 1/273 normalization factor. So the Matrix is stored on the file after normalization.
 
-<<<<<<< HEAD
 The output images are stored in out_mats inside output directory.
 
-=======
 The output images are stored in out_mats inside output directory.
->>>>>>> 3fd407e (Run the project on windows Powershell)

helpers/load_img.py

@@ -8,12 +8,10 @@
 if __name__ == "__main__":
 
     f = open(sys.argv[1] ,"r")
-<<<<<<< HEAD
     shape = list(map(int, f.readline().split()))
     for idx in range(shape[0]):
         im = np.empty(shape=(shape[1], shape[2], shape[3]))
         for i in range(shape[1]):
-=======
     # Read the number of images
     shape = list(map(int, f.readline().split()))
 
@@ -25,7 +23,6 @@
         # Read the image
         for i in range(shape[1]):
 
->>>>>>> 3fd407e (Run the project on windows Powershell)
             row = f.readline().split()
             assert(len(row) == shape[2])  # 300
             for j in range(shape[2]):

src/Filter.cpp

@@ -1,6 +1,20 @@
 #include "Filter.hpp"
 
 // allocate memory for a tensor
+
+// Explanation of the function get_tensor:
+// This function takes in three integers x, y, and z, and returns a 3D tensor of size x*y*z.
+// The tensor is a 3D array of doubles, and is allocated on the heap.
+// The function first allocates memory for an array of pointers to pointers to pointers of doubles.
+// Then, it allocates memory for each row of the tensor, which is an array of pointers to pointers of doubles.
+// Finally, it allocates memory for each element of the tensor, which is an array of doubles.
+// The function returns the 3D tensor.
+
+// What does tensor mean?
+// A tensor is a generalization of scalars, vectors, and matrices to higher dimensions.
+// In this case, the tensor is a 3D array of doubles, which is used to store the weights of the filter.
+
+
 double ***get_tensor(int x, int y, int z) {
   double ***ret = new double**[x];
   for (int i = 0; i < x; i++) {
@@ -13,14 +27,12 @@ double ***get_tensor(int x, int y, int z) {
 }
 
 // Constructor
-Filter::Filter(int _window, int _depth) 
-  : window(_window), depth(_depth) {
+Filter::Filter(int _window, int _depth) : window(_window), depth(_depth) {
   w = get_tensor(window, window, depth); 
 }
 
 // Constructor with initial weights
-Filter::Filter(double ***_w, int _window, int _depth, int _b) 
-  : window(_window), depth(_depth), b(_b) {
+Filter::Filter(double ***_w, int _window, int _depth, int _b) : window(_window), depth(_depth), b(_b) {
   w = get_tensor(window, window, depth); 
   for (int i = 0; i < window; ++i) {
     for (int j = 0; j < window; ++j) {

src/main.cpp

@@ -83,13 +83,21 @@ int main(int argc, char *argv[]) {
   }
 
   int width, num_images, height, depth;
+
+  // As requested in the assignment, we will use a stride of 1
+  // As an option feature, we will also use padding of 1
   int stride = 1, padding = 1; 
+
+
   ifile >> num_images >> width >> height >> depth;
+  
   ofile << num_images << " "; 
   cerr << num_images << " "; 
 
   Convolution clayer(width, height, depth, w_size, stride, padding, filters.size()); 
+
   double ***input;
+
   input = get_tensor(width, height, depth); 
 
   #pragma omp parallel for // Parallelize the loop