Done with project.

Author: dembasowfr

Makefile

@@ -0,0 +1,28 @@
+
+
+CC=g++ 
+CFLAGS= -std=gnu++11 -O2 -Iinclude -I/usr/include/python3.10
+LDFLAGS= -lpython3.10
+DEBUG=-g
+SRC_DIR=src
+INCLUDE_DIR=include
+BIN_DIR=bin
+OUTPUT_DIR=output
+
+all: $(BIN_DIR) main
+
+main: $(BIN_DIR)/Convolution.o $(BIN_DIR)/Filter.o $(SRC_DIR)/main.cpp
+	$(CC) $(CFLAGS) $(SRC_DIR)/main.cpp $(BIN_DIR)/Convolution.o $(BIN_DIR)/Filter.o -o $(OUTPUT_DIR)/main $(LDFLAGS)
+
+$(BIN_DIR)/Convolution.o: $(SRC_DIR)/Convolution.cpp $(INCLUDE_DIR)/Convolution.hpp $(BIN_DIR)/Filter.o
+	$(CC) $(CFLAGS) -c $(SRC_DIR)/Convolution.cpp -o $(BIN_DIR)/Convolution.o
+
+$(BIN_DIR)/Filter.o: $(SRC_DIR)/Filter.cpp $(INCLUDE_DIR)/Filter.hpp
+	$(CC) $(CFLAGS) -c $(SRC_DIR)/Filter.cpp -o $(BIN_DIR)/Filter.o
+
+$(BIN_DIR):
+	mkdir -p $(BIN_DIR)
+
+clean: 
+	rm -rf $(BIN_DIR) $(OUTPUT_DIR)/main
+

README.md

@@ -0,0 +1,82 @@
+# Convolutional filter(s) for images
+
+* Images are stored in folder images/. All images should be of the same size.
+
+* Python Imaging Library (PIL) was used to convert images into RGB matrices and to convert filtered matrices back to images. PIL was preferred over other C++ libraries due to ease of use.
+
+## 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)
+  * 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.
+
+```cpp
+for (int id = 0; id < num_images; ++id) {
+  ...
+  auto output = clayer.conv2d(input, filters);
+  ...
+}
+```
+
+## Steps to run
+* First and foremost install the required libraries:
+
+```bash
+sudo apt update
+sudo apt install python3-pip
+pip install -r requirements.txt
+```
+
+* Compile using make. Build file for convolutional filter demo program is 'main'. See run.sh for a complete run
+
+* The ```run.sh``` file allows us to run both ```makefile``` and the rest of python commands that's going to execute the overall project.
+To run the project:
+1. First of all make sure that ```run.sh``` has excutable permissions:
+
+```bash
+chmod +x run.sh
+```
+2. Run the ```run.sh``` file:
+
+
+```bash
+./run.sh
+```
+
+```bash
+rm *.o main
+g++  -std=gnu++11 -O2 filter.hpp -o filter.o
+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.
+
+```bash
+python3 make_mats.py img_mats/out.dat
+```
+
+* Run the convolutional filter (read from standard input)
+
+```bash
+./main img_mats/out.dat img_mats/filter_out.dat < filter.txt
+```
+
+* Make output images from matrices
+
+```bash
+python3 load_img.py img_mats/filter_out.dat out_mats
+```
+
+## Results
+
+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.
+
+The output images are stored in out_mats inside output directory.
+

backup.cpp

@@ -0,0 +1,101 @@
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <vector>
+#include "Filter.hpp"
+#include "Convolution.hpp"
+
+using namespace std;
+
+int w_size, bias;     // kernel window size
+double** kernel; // image kernel 
+vector<Filter*> filters;
+
+void push_filter(int idx) {     
+  // make edge detector for color idx 
+  double ***ed = get_tensor(w_size, w_size, 3); 
+  for (int i = 0; i < w_size; ++i) {
+    for (int j = 0; j < w_size; ++j) {
+      ed[i][j][idx] = kernel[i][j];
+    }
+  }
+  Filter *f = new Filter(ed, w_size, 3, bias);
+  f->normalize();
+  filters.push_back(f);
+}
+
+int main(int argc, char *argv[]) {
+
+  //  input the kernel matrix
+  cin >> w_size >> bias;
+  kernel = new double*[w_size]; 
+  for (int i = 0; i < w_size; i++) {
+    kernel[i] = new double[w_size];
+    for (int j = 0; j < w_size; j++) {
+      cin >> kernel[i][j]; 
+    }
+  }
+
+  push_filter(0); // R
+  push_filter(1); // G
+  push_filter(2); // B
+  if (argc < 3) {
+    cerr << "Usage <input_data file name> <output file name>" << endl;
+    return 1;
+  }
+  // output file will be written in the same format as input file
+  ifstream ifile (argv[1]);   
+  ofstream ofile (argv[2]);
+  if (!ofile.is_open()) {
+    cerr << "Unable to open " << argv[1] << endl;
+    return 1;
+  }
+  if (!ifile.is_open()) {
+    cerr << "Unable to open " << argv[0] << endl;
+    return 1;
+  }
+
+  int width, num_images, height, depth;
+  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); 
+  
+  for (int id = 0; id < num_images; ++id) {
+
+    // read one image
+    for (int i = 0; i < width; ++i) {
+      for (int j = 0; j < height; ++j) {
+        for (int k = 0; k < depth; ++k) {
+          ifile >> input[i][j][k];
+          if (ifile.peek() == ',') ifile.ignore();
+        }
+      }
+    }
+    auto output = clayer.conv2d(input, filters);
+    double ***out_volume = get<3>(output);
+    int o_width = get<0>(output), o_height = get<1>(output), o_depth = get<2>(output);
+    if (id == 0) {
+      // print image dimensions only the first time
+      ofile << o_width << " " << o_height << " " << o_depth << "\n";
+      cerr << o_width << " " << o_height << " " << o_depth << "\n";
+    }
+
+    for (int i = 0; i < o_width; ++i) {
+      for (int j = 0; j < o_height; ++j) {
+        ofile << out_volume[i][j][0] << "," << out_volume[i][j][1] 
+                << "," << out_volume[i][j][2] << " ";      
+      }
+      ofile << "\n";
+    }
+    ofile << "\n";
+  }
+  ifile.close();
+  ofile.close();
+
+  return 0; 
+}

bin/Convolution.o

@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+from PIL import Image
+import pylab
+import sys
+import numpy as np
+
+if __name__ == "__main__":
+    
+    f = open(sys.argv[1] ,"r")
+    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]):
+            row = f.readline().split()
+            assert(len(row) == shape[2])  # 300
+            for j in range(shape[2]):
+                im[i][j] = list(map(float, row[j].split(",")))
+        result = Image.fromarray(im.astype(np.uint8))
+        result.save(sys.argv[2] + "/" + str(idx) + ".bmp")
+        f.readline()    # empty line

bin/Filter.o

@@ -0,0 +1,36 @@
+#!/usr/bin/python
+
+import numpy as np
+from PIL import Image
+import pylab
+import sys
+import os
+
+dirname = 'input/'
+#colored = ["airplane.png", "lena.png",  "fruits.png"] should be 300 * 300 * 3 = (300, 300, 3)
+#gray = ["cloud.png", "horse.png", "moon.png", "view.png"] # should be 300 * 300 * 1 = (300, 300)
+
+def append_matrix(filepath, outf):
+    img = Image.open(filepath)
+    im = np.asarray(img, dtype='float64')
+    #print(im.shape)
+    for i in range(im.shape[0]):
+        for j in range(im.shape[1]):
+            outf.write("%f,%f,%f " %(im[i][j][0], im[i][j][1], im[i][j][2]))
+        outf.write('\n')
+    outf.write('\n')
+
+if __name__ == "__main__":
+    f = open(sys.argv[1], "w")
+
+    # 3 for color, 1 for grey
+    #depth = 3   
+    depth = 3
+
+    foldername = dirname + 'grey/' # grey for grey folder(which actually contains colored images)
+
+    filenames = os.listdir(foldername)
+    f.write("%d 300 300 %d\n" % (len(filenames), depth)) # image tensor dimensions
+
+    for filename in filenames:
+        append_matrix(foldername + filename, f)

helpers/load_img.py

@@ -0,0 +1,25 @@
+#ifndef CONVOLUTION_H
+#define CONVOLUTION_H
+
+#include <vector>
+#include <tuple>
+#include "Filter.hpp"
+
+class Convolution {
+  int in_width, in_height, in_depth,
+      n_filters, window, stride, padding,
+      out_width, out_height, out_depth;
+
+public:
+  Convolution(int _width, int _height, int _depth, int _window, int _stride = 1, int _padding = 0, int n_filters = 1);
+
+  ~Convolution();
+
+  // Applies convolutional filters in filters to input volume x
+  // x treated as in_width * in_height * in_depth 
+  // assumed n_filters elements in filters vector
+  // returns shape of the output volume and pointer to the memory block
+  std::tuple<int, int, int, double ***> conv2d(double ***x, const std::vector<Filter*> &filters);
+};
+
+#endif

helpers/make_mats.py

@@ -0,0 +1,22 @@
+#ifndef FILTER_HPP
+#define FILTER_HPP  
+
+#include <cmath>
+
+// allocate memory for a tensor
+double ***get_tensor(int x, int y, int z);
+
+class Filter {
+public:
+  double ***w, b;     // kernel matrix, bias term
+  int window, depth;
+
+  Filter(int _window, int _depth);
+  Filter(double ***_w, int _window, int _depth, int _b = 0);
+  ~Filter();
+
+  // normalize the tensor
+  void normalize();
+};
+
+#endif