Test System Configuration

• Ubuntu 20.04 LTS on WSL 1, Windows 10
• Python 3.8
• Boost 1.71 [To see Boost version, open up /usr/include/boost/version.hpp and look for #define BOOST_LIB_VERSION]

Install dependencies, if needed

• sudo apt-get install libboost-all-dev
• sudo apt install python-dev or sudo apt-get install python3-dev depending upon the Python
• sudo apt install libboost-numpy-dev

Find out library names and their paths

We need the library names and their paths for linking.

• Python - Find out where the pyconfig is [use find /usr/include/ -name pyconfig*]. In my system it was at /usr/include/python3.8/.
• Boost Python - use find /usr/lib -name libboost*. In my system, boost_python library was at /usr/lib/x86_64-linux-gnu/libboost_python38. So the name of the library is boost_python38.
• Boost Numpy - Just like Boost Python, I found out libboost_numpy was at /usr/lib/x86_64-linux-gnu/libboost_numpy38, and hence the library name was boost_numpy38

Code

We need to create a shared library (.so) using Boost by compiling cpp code and linking existing libraries (boost_python, python, boost_numpy).

CPP header file - sample_interface.h

#ifndef SAMPLE_INTERFACE
#define SAMPLE_INTERFACE
#include <boost/python.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/stl_iterator.hpp>
#include <boost/python/numpy.hpp>

namespace np = boost::python::numpy;
namespace bpy = boost::python;

class SampleInterface{
    public:
    SampleInterface();
    np::ndarray foo_bar(np::ndarray &input_array);
};
#endif // end of SAMPLE_INTERFACE

CPP definition file - sample_interface.cpp

#include "sample_interface.h" 
#include <iostream> 
using namespace std;

SampleInterface::SampleInterface(){
    np::initialize();
}

np::ndarray SampleInterface::foo_bar(np::ndarray &input_array){
    return input_array;
}

BOOST_PYTHON_MODULE(cpp_interface) { // cpp_interface should be name of .so file
    using namespace boost::python;
    class_<SampleInterface>("SampleInterface")
        .def("foo", &SampleInterface::foo_bar)
        ;
    }

Generating shared library (.so) file

g++ sample_interface.cpp -I/usr/include/python3.8/ -lboost_python38 -lpython3.8 -lboost_numpy38 -fPIC --shared -o cpp_interface.so

Python file - calling_cpp_from_python.py

import numpy as np
import cpp_interface

arr = np.random.randint(1,10, size=(2, 3))
print("shape of input array:", arr.shape)
print("Input array:")
print(arr)

interface = cpp_interface.SampleInterface()
out_arr = interface.foo(arr)
print("shape of array from cpp:", out_arr.shape)
print("Output array:")
print(out_arr)

All of these snippets are available here.

Acknowledgement

• Sambhu Surya Mohan

Reference:

• Interfacing C++ and Python with Boost.Python

The output shape of a convolution operation is defined as follows,

The Convolution layer in TensorFlow has two types of padding- VALID and SAME.

VALID padding

In VALID padding no pad value is added to the input. Hence, the shape of the array is preserved. Below is the equation for the output shape.

SAME padding

In SAME padding we have to pad such a way that,

To satisfy the above constraints, the input array has to be modified. From deriving the number of padding needed from the first equation, we get,

Now that we have the number of padding along the height, we have to decide the number of paddings that has to be applied on the top and bottom of the input array. In TensorFlow, the padding for the top and bottom is calculated as follows,

The above equations imply that bottom_padding has higher priority than top_padding.

Similarly, for deciding padding for left and right,

The above equations imply that right_padding has higher priority than left_padding. It means that when the number of pad along width is one, then we should pad right.

Let’s look at the code.

def calculate_padding_for_same_pad(input_sz, kernel_sz, stride):
    output_sz = np.ceil(input_sz / stride)
    total_pad = (output_sz - 1) * stride - input_sz + kernel_sz
    low_priority_pad = total_pad // 2
    high_priority_pad = total_pad - low_priority_pad
    return low_priority_pad, high_priority_pad
pad_top, pad_bottom = calculate_padding_for_same_pad(input_sz_h, kernel_sz_h, stride_h)
pad_left, pad_right = calculate_padding_for_same_pad(input_sz_w, kernel_sz_w, stride_w)

Reference:

• What is the behavior of SAME padding when stride is greater than 1?
• Padding schemes in TensorFlow

In convolution the signal $g(t)$ is flipped and convolved(passed through) on the input signal $f(t)$. Using convolution we look for what will be the output of the filter, $g(t)$ when it’s input is $x(t)$.

Using correlation we check whether a signal $g(t)$ is present in a given noisy signal $x(t)$. One pratical application is template matching in computer vision. The correlation is given by

TODO: Relationship between convolution and correlation using Numpy

TODO: Relationship between convolution, correlation and fft

Reference:

• A guide on convolution and correlation
• Understanding convolutions
• Difference between convolution and correlation
• Correlation of two images using FFT

Each image in the dataset should have a corresponding txt file. The bounding box in the image is represented by each line in the text file. The syntax of the line is as follows:

class_id x y w h

x and y are coordinates of the mid point of the bounding box. w and h are the width and height of the bounding box. The values for x, y, w and h are expressed relative to the image(ratio).

Let’s say, im_w and im_h are the width and height of an image, and (x_min, y_min) and (x_max, y_max) are two diagonally opposite coordinates of a bounding box. To convert them into YOLO metrics, we find the midpoint of the bounding box- ((x_min + x_max) / 2 , (y_min + y_max) / 2). The width and height of bounding box is given by x_max - x_min and y_max - y_min. Then to express the values relative to image, we divide these values by im_w and im_h.

x = (x_min + x_max) / (2 * im_w)

y = (y_min + y_max) / (2 * im_h)

w = (x_max - x_min) / im_w

h = (y_max - y_min) / im_h

Below is the Python code.

def convert(im_w, im_h, x_min, x_max, y_min, y_max):
    dw = 1./im_w
    dh = 1./im_h
    x = (x_min + x_max)/2.0
    y = (y_min + y_max)/2.0
    w = x_max - x_min
    h = y_max - y_min
    x = x*dw
    w = w*dw
    y = y*dh
    h = h*dh
    return (x,y,w,h)

def deconvert(im_w, im_h, x, y, w, h):
    ox = float(x)
    oy = float(y)
    ow = float(w)
    oh = float(h)
    x = ox*im_w
    y = oy*im_h
    w = ow*im_w
    h = oh*im_h
    xmax = (((2*x)+w)/2)
    xmin = xmax-w
    ymax = (((2*y)+h)/2)
    ymin = ymax-h
    return [int(xmin),int(ymin),int(xmax),int(ymax)]

Manivannan has shared an annotation tool and wrote about how to use it. Please note that his tool is in Python 2 and with some edits will work on Python 3.