init commit

Author: yunlongdong

infCNN/Core.py

@@ -0,0 +1,39 @@
+class Op:
+    def __init__(self, name):
+        self.name = name
+        pass
+    
+    def __repr__(self):
+        return 'Op:' + self.name
+
+    def forward(self, x):
+        pass
+
+    def backward(self, grad_y):
+        pass
+    
+    def __call__(self, x):
+        return self.forward(x)
+        
+
+class Layer:
+    def __init__(self, name):
+        self.name = name
+        self.param = None
+        pass
+    
+    def __repr__(self):
+        return 'layer:' + self.name
+
+    def forward(self, x):
+        pass
+
+    def backward(self, grad_y):
+        pass
+
+    def __call__(self, x):
+        return self.forward(x)
+
+    
+
+

infCNN/LayerLib.py

@@ -0,0 +1,125 @@
+from .Core import Layer
+from .im2col import im2col_indices
+import numpy as np
+
+class Dense(Layer):
+
+    def __init__(self, n_in, n_out):
+        super().__init__('dense_{}_{}'.format(n_in, n_out))
+        self.n_in = n_in
+        self.n_out = n_out
+        self.K =  np.random.randn(n_out, n_in)
+        self.bias = np.zeros(n_out)
+
+    def forward(self, x):
+        self.x = x
+        w = self.K
+        # the dense layer math: y = x*w
+        y = w.dot(x.T)
+        return y.T + self.bias.reshape((1, -1))
+
+    def load_from_torch(self, weights, bias):
+        self.K = weights
+        self.bias = bias
+    
+
+class Conv2d(Layer):
+    
+    def __init__(self, C_in, C_out, K_s, Stride):
+        """
+        Params:
+            in channels, out channles, kernel size, stride
+        """
+        super().__init__("conv_{}_{}x{}x{}".format(C_out, C_in, K_s, K_s))
+        self.c_in = C_in
+        self.c_out = C_out
+        self.k_s = K_s
+        self.stride = Stride
+        self.pad_size = int((K_s -1)/2)
+        self.K = np.zeros((C_out, C_in, K_s, K_s))
+        self.bias = np.zeros(C_out)
+
+    def forward(self, X):
+        out = conv_forward(X, self.K, self.bias, stride=self.stride, padding=self.pad_size)
+        return out
+
+        
+    def load_from_torch(self, weights, bias):
+        self.K = weights
+        self.bias = bias
+
+
+def conv_forward(X, W, b, stride=1, padding=1):
+    cache = W, b, stride, padding
+    n_filters, d_filter, h_filter, w_filter = W.shape
+    n_x, d_x, h_x, w_x = X.shape
+    h_out = (h_x - h_filter + 2 * padding) / stride + 1
+    w_out = (w_x - w_filter + 2 * padding) / stride + 1
+
+    if not h_out.is_integer() or not w_out.is_integer():
+        raise Exception('Invalid output dimension!')
+
+    h_out, w_out = int(h_out), int(w_out)
+
+    X_col = im2col_indices(X, h_filter, w_filter, padding=padding, stride=stride)
+    W_col = W.reshape(n_filters, -1)
+
+    out = W_col @ X_col
+    out = (out.T + b[:]).T
+    out = out.reshape(n_filters, h_out, w_out, n_x)
+    out = out.transpose(3, 0, 1, 2)
+
+    cache = (X, W, b, stride, padding, X_col)
+
+    return out# , cache
+
+
+
+
+if __name__ == "__main__":
+    # data = np.arange(16).reshape((1, 1, 4, 4))
+    data = np.random.randn(2, 3, 200, 200)
+
+
+    import torch.nn as nn
+    import torch
+    from time import time
+
+    conv_torch = nn.Conv2d(3, 5, 3, 1, 1)
+    conv = Conv2d(3, 5, 3, 1)
+    # conv_torch.weight = nn.Parameter(torch.FloatTensor(np.arange(9).reshape(1, 1, 3, 3)))
+    # conv_torch.bias = nn.Parameter(torch.FloatTensor(np.zeros(1)))
+    w = conv_torch.weight.detach().numpy()
+    b = conv_torch.bias.detach().numpy()
+
+    start = time()
+    out_torch = conv_torch(torch.FloatTensor(data)).detach().numpy()
+    print('torch time:', time() - start)
+    
+    conv.load_from_torch(w, b)
+    start = time()
+    out = conv(data)
+    print('acw time:', time() - start)
+
+    print('torch:', out_torch.shape)
+    print('acw:', out.shape)
+    print(np.sum(out-out_torch))
+
+
+    data = np.random.randn(2, 10)
+
+    dense_torch = nn.Linear(10, 20)
+    w = dense_torch.weight.detach().numpy()
+    b = dense_torch.bias.detach().numpy()
+
+    dense = Dense(10, 20)
+
+    start = time()
+    out_torch = dense_torch(torch.FloatTensor(data)).detach().numpy()
+    print('torch time:', time() - start)
+
+    dense.load_from_torch(w, b)
+    start = time()
+    out = dense(data)
+    print('acw time:', time() - start)
+    print(np.sum(out-out_torch))

infCNN/OpLib.py

@@ -0,0 +1,84 @@
+from .Core import Op 
+from .im2col import im2col_indices
+import numpy as np
+
+    
+class ReLU(Op):
+
+    def __init__(self):
+        super().__init__('ReLU')
+
+    def forward(self, x):
+        self.x = x
+        return (x>0) * x
+
+
+class Flatten(Op):
+
+    def __init__(self):
+        super().__init__('Flatten')
+
+    def forward(self, x):
+        n = x.shape[0]
+        self.x = x
+        return x.reshape((n, -1))
+
+
+class Sigmoid(Op):
+
+    def __init__(self):
+        super().__init__('Sigmoid')
+
+    def forward(self, x):
+        self.x = x
+        return 1/(1 + np.exp(-x))
+
+class Softmax(Op):
+    def __init__(self):
+        super().__init__('Sofmax')
+
+    def forward(self, X, axis=-1):
+        eX = np.exp((X.T - np.max(X, axis=axis)).T)
+        return (eX.T / eX.sum(axis=axis)).T
+
+
+
+
+class MaxPool(Op):
+
+    def __init__(self, size=2, stride=2):
+        super().__init__('MaxPool_{}x{}s{}'.format(size, size, stride))
+        self.size = size
+        self.stride = stride
+
+    def _pool_forward(self, X, pool_fun, size=2, stride=2):
+        n, d, h, w = X.shape
+        h_out = (h - size) / stride + 1
+        w_out = (w - size) / stride + 1
+    
+        if not w_out.is_integer() or not h_out.is_integer():
+            raise Exception('Invalid output dimension!')
+    
+        h_out, w_out = int(h_out), int(w_out)
+    
+        X_reshaped = X.reshape(n * d, 1, h, w)
+        X_col = im2col_indices(X_reshaped, size, size, padding=0, stride=stride)
+    
+        out, pool_cache = pool_fun(X_col)
+    
+        out = out.reshape(h_out, w_out, n, d)
+        out = out.transpose(2, 3, 0, 1)
+    
+        cache = (X, size, stride, X_col, pool_cache)
+    
+        return out# , cache
+    
+    def maxpool(self, X_col):
+        max_idx = np.argmax(X_col, axis=0)
+        out = X_col[max_idx, range(max_idx.size)]
+        return out, max_idx
+
+    def forward(self, x):
+        return self._pool_forward(x, self.maxpool, self.size, self.stride)
+
+

infCNN/__init__.py

@@ -0,0 +1,2 @@
+from .LayerLib import * 
+from .OpLib import * 

infCNN/im2col.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+
+def get_im2col_indices(x_shape, field_height, field_width, padding=1, stride=1):
+    # First figure out what the size of the output should be
+    N, C, H, W = x_shape
+    assert (H + 2 * padding - field_height) % stride == 0
+    assert (W + 2 * padding - field_height) % stride == 0
+    out_height = int((H + 2 * padding - field_height) / stride + 1)
+    out_width = int((W + 2 * padding - field_width) / stride + 1)
+
+    i0 = np.repeat(np.arange(field_height), field_width)
+    i0 = np.tile(i0, C)
+    i1 = stride * np.repeat(np.arange(out_height), out_width)
+    j0 = np.tile(np.arange(field_width), field_height * C)
+    j1 = stride * np.tile(np.arange(out_width), out_height)
+    i = i0.reshape(-1, 1) + i1.reshape(1, -1)
+    j = j0.reshape(-1, 1) + j1.reshape(1, -1)
+
+    k = np.repeat(np.arange(C), field_height * field_width).reshape(-1, 1)
+
+    return (k.astype(int), i.astype(int), j.astype(int))
+
+
+def im2col_indices(x, field_height, field_width, padding=1, stride=1):
+    """ An implementation of im2col based on some fancy indexing """
+    # Zero-pad the input
+    p = padding
+    x_padded = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p)), mode='constant')
+
+    k, i, j = get_im2col_indices(x.shape, field_height, field_width, padding, stride)
+
+    cols = x_padded[:, k, i, j]
+    C = x.shape[1]
+    cols = cols.transpose(1, 2, 0).reshape(field_height * field_width * C, -1)
+    return cols
+
+
+def col2im_indices(cols, x_shape, field_height=3, field_width=3, padding=1,
+                   stride=1):
+    """ An implementation of col2im based on fancy indexing and np.add.at """
+    N, C, H, W = x_shape
+    H_padded, W_padded = H + 2 * padding, W + 2 * padding
+    x_padded = np.zeros((N, C, H_padded, W_padded), dtype=cols.dtype)
+    k, i, j = get_im2col_indices(x_shape, field_height, field_width, padding, stride)
+    cols_reshaped = cols.reshape(C * field_height * field_width, -1, N)
+    cols_reshaped = cols_reshaped.transpose(2, 0, 1)
+    np.add.at(x_padded, (slice(None), k, i, j), cols_reshaped)
+    if padding == 0:
+        return x_padded
+    return x_padded[:, :, padding:-padding, padding:-padding]

net.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.io import loadmat
+# infCNN layer
+from infCNN import Conv2d, Dense
+# infCNN op 
+from infCNN import ReLU, Flatten, MaxPool, Softmax 
+from time import time
+
+# op
+relu = ReLU()
+flatten = Flatten()
+maxpool = MaxPool()
+softmax = Softmax()
+
+class LeNet():
+    def __init__(self):
+        self.conv1 = Conv2d(1, 6, 5, 1)
+        self.conv2 = Conv2d(6, 16, 5, 1)
+        self.fc1   = Dense(784, 120)
+        self.fc2   = Dense(120, 84)
+        self.fc3   = Dense(84, 10)
+
+        self.weights = [self.conv1, self.conv2, self.fc1, self.fc2, self.fc3]
+
+    def forward(self, x):
+        out = relu(self.conv1(x))
+        # print(out.shape)
+        out = maxpool(out)
+        # print(out.shape)
+        out = relu(self.conv2(out))
+        # print(out.shape)
+        out = maxpool(out)
+        # print(out.shape)
+        out = flatten(out)
+        # print(out.shape)
+        out = relu(self.fc1(out))
+        # print(out.shape)
+        out = relu(self.fc2(out))
+        # print(out.shape)
+        out = self.fc3(out)
+        # print(out.shape)
+        return softmax(out)
+
+    def __call__(self, x):
+        return self.forward(x)
+
+    def load_mat(self, fn):
+        data = loadmat(fn)
+        w_len = len(data)-4
+        print('load num of weights:', w_len)
+        # minus 4 to skip the header
+        for i in range(w_len//2+1):
+            w = data[str(2*i)]
+            b = data[str(2*i+1)]
+            print(i, w.shape, b.shape)
+            self.weights[i].load_from_torch(data[str(2*i)], data[str(2*i+1)][0, :])
+        print('load done!')
+
+if __name__ == "__main__":
+    net = LeNet()
+    data =  np.ones((1, 1, 28, 28))
+    net.load_mat('train/lenet.mat')
+    start = time()
+    print(net(data))
+    print('infCNN LeNet time:', time()-start)
+

readme.md

@@ -0,0 +1,25 @@
+## infCNN
+A pure numpy-based inference framework for CNN. The infCNN supports the inference of model trained on pytorch.
+
+In general, all the elements used in the inference of CNN are divided into ```op``` and ```layer```. ```op``` contains no trainable weights such as "relu, sigmoid, softmax, maxpool, flatten", ```layer``` contains trainable weights such as "conv2d, dense". The ```op``` and ```layer``` implemented are very few now.
+
+#### Inference
+
+Example is shown in ```net.py```, which shows the inference of a LeNet CNN. Weights converted from pytorch model are loaded here. To be noted that ```net.py``` should align with ```train/lenet.py``` since they should have the same model. Just replacing ```nn.Conv2d/Linear``` with ```inferCNN.Conv2d/Dense```   will work.
+
+#### Training on pytorch
+
+The training on pytorch is regular, which can be seen in ```train/``` folder. The weights of CNN are exported to ```.mat``` file.
+
+
+
+#### References
+
+* https://github.com/wiseodd/hipsternet
+* https://github.com/pytorch/examples/blob/master/mnist/main.py
+
+
+
+
+
+