FC2カウンター FPGAの部屋 「ゼロから作るDeep Learning」の畳み込みニューラルネットワークのハードウェア化2

FPGAやCPLDの話題やFPGA用のツールの話題などです。 マニアックです。 日記も書きます。

FPGAの部屋

FPGAの部屋の有用と思われるコンテンツのまとめサイトを作りました。Xilinx ISEの初心者の方には、FPGAリテラシーおよびチュートリアルのページをお勧めいたします。

「ゼロから作るDeep Learning」の畳み込みニューラルネットワークのハードウェア化2

「ゼロから作るDeep Learning」の畳み込みニューラルネットワークのハードウェア化1”の続き。

前回は、「ゼロから作るDeep Learning」の7章 畳み込みニューラルネットワークの2層のニューラルネットワークをハードウェア化してFPGA に実装してみようということで、重みなどを量子化して、その精度を確認する方法を書いた。
今回は、そのPython コードを貼っておく。

(注:今回のPython コードはoreilly-japan/deep-learning-from-scratch をクローンした環境下でないと動作しない。私は ch5 フォルダの下で動作させている。なお、「ゼロから作るDeep Learning」を購入してから試してほしい)

なお、紹介するPython コードはdeep-learning-from-scratch/ch07/に置いてあるものを変更している。それらのPython コードはMIT ライセンスなので、私が変更、追加したコードもMIT ライセンスを引き継ぐものとする。

最初に、layers_int.py から貼っておく。

# layers_int.py
# 元になったコードは、https://github.com/oreilly-japan/deep-learning-from-scratch にあります。
# 改変したコードもMITライセンスとします。 2017/06/14 by marsee

# coding: utf-8
import numpy as np
from common.functions import *
from common.util import im2col, col2im

AF_OUT_MAG = 2 ** 5 # 出力の小数部
AF_OUT_INT = 2 ** 6 # 出力の整数部(+符号1ビット)
AF_WB_MAG = 2 ** 8 # 重みとバイアスの小数部
AF_WB_INT = 2 ** 1 # 重みとバイアスの整数部(+符号1ビット)

COV_OUT_MAG = 2 ** 7 # 出力の小数部
COV_OUT_INT = 2 ** 2 # 出力の整数部(+符号1ビット)
COV_WB_MAG = 2 ** 8 # 重みとバイアスの小数部
COV_WB_INT = 2 ** 1 # 重みとバイアスの整数部(+符号1ビット)

DEBUG = 1;

class Relu:
    def __init__(self):
        self.mask = None

    def forward_int(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def forward_msg(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout

        return dx


class Sigmoid:
    def __init__(self):
        self.out = None

    def forward_int(self, x):
        out = sigmoid(x)
        self.out = out
        return out

    def forward(self, x):
        out = sigmoid(x)
        self.out = out
        return out

    def forward_msg(self, x):
        out = sigmoid(x)
        self.out = out
        return out

    def backward(self, dout):
        dx = dout * (1.0 - self.out) * self.out

        return dx


class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b

        self.W_int = W
        self.b_int = b

        self.x = None
        self.original_x_shape = None
        # 重み・バイアスパラメータの微分
        self.dW = None
        self.db = None

    def forward_int(self, x):
        if (DEBUG == 1):
            print("x shape ={0}".format(x.shape))
            print("np.max(self.W) = {0}".format(np.max(self.W)))

        # テンソル対応
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        # x は量子化できているはず
        # wとbをINT8の範囲に修正 2017/05/22 by marsee
        self.W_int = np.array(self.W*AF_WB_MAG+0.5, dtype=int)
        self.b_int = np.array(self.b*AF_WB_MAG+0.5, dtype=int)

        for i in range(self.W_int.shape[0]):
            for j in range(self.W_int.shape[1]):
                if (self.W_int[i][j] > AF_WB_MAG*AF_WB_INT/2-1):
                    self.W_int[i][j] = AF_WB_MAG*AF_WB_INT/2-1
                elif (self.W_int[i][j] < -AF_WB_MAG*AF_WB_INT/2):
                    self.W_int[i][j] = -AF_WB_MAG*AF_WB_INT/2;

        for i in range(self.b_int.shape[0]):
            if (self.b_int[i] > AF_WB_MAG*AF_WB_INT/2-1):
                self.b_int[i] = AF_WB_MAG*AF_WB_INT/2-1
            elif (self.b_int[i] < -AF_WB_MAG*AF_WB_INT/2):
                self.b_int[i] = -AF_WB_MAG*AF_WB_INT/2
        
        self.W_int = np.array(self.W_int, dtype=float)
        self.b_int = np.array(self.b_int, dtype=float)
        
        self.W_int = self.W_int/AF_WB_MAG
        self.b_int = self.b_int/AF_WB_MAG

        out = np.dot(self.x, self.W_int) + self.b_int

        if (DEBUG == 1):
            print("np.max(self.W) = {0}".format(np.max(self.W)))
            print("np.max(self.b) = {0}".format(np.max(self.b)))

            print("x reshape ={0}".format(x.shape))
            print("np.max(x) = {0}".format(np.max(x)))
            print("np.min(x) = {0}".format(np.min(x)))        
            #print("x = {0}".format(self.x))
            print(self.W_int.shape)
            print("np.max(self.W_int) = {0}".format(np.max(self.W_int)))
            print("np.min(self.W_int) = {0}".format(np.min(self.W_int)))
            print(self.b_int.shape)
            print("np.max(self.b_int) = {0}".format(np.max(self.b_int)))
            print("np.min(self.b_int) = {0}".format(np.min(self.b_int)))
            print(out.shape)
            print("np.max(out) = {0}".format(np.max(out)))
            print("np.min(out) = {0}".format(np.min(out)))
            #print("out = {0}".format(out))

        out = np.array(out*AF_OUT_MAG+0.5, dtype=int)
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                if (out[i][j] > AF_OUT_MAG*AF_OUT_INT/2-1):
                    out[i][j] = AF_OUT_MAG*AF_OUT_INT/2-1
                elif (out[i][j] < -AF_OUT_MAG*AF_OUT_INT/2):
                    out[i][j] = -AF_OUT_MAG*AF_OUT_INT/2
        out = np.array(out, dtype=float)
        out = out/AF_OUT_MAG

        if (DEBUG == 1):
            print("np.max(out2) = {0}".format(np.max(out)))
            print("np.min(out2) = {0}".format(np.min(out)))

        return out

    def forward(self, x):
        # テンソル対応
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        out = np.dot(self.x, self.W) + self.b

        return out

    def forward_msg(self, x):
        print("x shape ={0}".format(x.shape))
        
        # テンソル対応
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        out = np.dot(self.x, self.W) + self.b

        print("x reshape ={0}".format(x.shape))
        print("np.max(x) = {0}".format(np.max(x)))
        print("np.min(x) = {0}".format(np.min(x)))        
        #print("x = {0}".format(self.x))
        print(self.W.shape)
        print("np.max(self.W) = {0}".format(np.max(self.W)))
        print("np.min(self.W) = {0}".format(np.min(self.W)))
        print(self.b.shape)
        print("np.max(self.b) = {0}".format(np.max(self.b)))
        print("np.min(self.b) = {0}".format(np.min(self.b)))
        print(out.shape)
        print("np.max(out) = {0}".format(np.max(out)))
        print("np.min(out) = {0}".format(np.min(out)))
        #print("out = {0}".format(out))

        return out

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        
        dx = dx.reshape(*self.original_x_shape)  # 入力データの形状に戻す(テンソル対応)
        return dx


class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None
        self.y = None # softmaxの出力
        self.t = None # 教師データ

    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        
        return self.loss

    def forward_msg(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        
        return self.loss

    def forward_int(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        
        return self.loss

    def backward(self, dout=1):
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size: # 教師データがone-hot-vectorの場合
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        
        return dx


class Dropout:
    """
    http://arxiv.org/abs/1207.0580
    """
    def __init__(self, dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None

    def forward_int(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def forward_msg(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def forward(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def backward(self, dout):
        return dout * self.mask


class BatchNormalization:
    """
    http://arxiv.org/abs/1502.03167
    """
    def __init__(self, gamma, beta, momentum=0.9, running_mean=None, running_var=None):
        self.gamma = gamma
        self.beta = beta
        self.momentum = momentum
        self.input_shape = None # Conv層の場合は4次元、全結合層の場合は2次元  

        # テスト時に使用する平均と分散
        self.running_mean = running_mean
        self.running_var = running_var  
        
        # backward時に使用する中間データ
        self.batch_size = None
        self.xc = None
        self.std = None
        self.dgamma = None
        self.dbeta = None

    def forward_int(self, x, train_flg=True):
        self.input_shape = x.shape
        if x.ndim != 2:
            N, C, H, W = x.shape
            x = x.reshape(N, -1)

        out = self.__forward(x, train_flg)
        
        return out.reshape(*self.input_shape)
            
    def forward_msg(self, x, train_flg=True):
        self.input_shape = x.shape
        if x.ndim != 2:
            N, C, H, W = x.shape
            x = x.reshape(N, -1)

        out = self.__forward(x, train_flg)
        
        return out.reshape(*self.input_shape)
            
    def forward(self, x, train_flg=True):
        self.input_shape = x.shape
        if x.ndim != 2:
            N, C, H, W = x.shape
            x = x.reshape(N, -1)

        out = self.__forward(x, train_flg)
        
        return out.reshape(*self.input_shape)
            
    def __forward(self, x, train_flg):
        if self.running_mean is None:
            N, D = x.shape
            self.running_mean = np.zeros(D)
            self.running_var = np.zeros(D)
                        
        if train_flg:
            mu = x.mean(axis=0)
            xc = x - mu
            var = np.mean(xc**2, axis=0)
            std = np.sqrt(var + 10e-7)
            xn = xc / std
            
            self.batch_size = x.shape[0]
            self.xc = xc
            self.xn = xn
            self.std = std
            self.running_mean = self.momentum * self.running_mean + (1-self.momentum) * mu
            self.running_var = self.momentum * self.running_var + (1-self.momentum) * var            
        else:
            xc = x - self.running_mean
            xn = xc / ((np.sqrt(self.running_var + 10e-7)))
            
        out = self.gamma * xn + self.beta 
        return out

    def backward(self, dout):
        if dout.ndim != 2:
            N, C, H, W = dout.shape
            dout = dout.reshape(N, -1)

        dx = self.__backward(dout)

        dx = dx.reshape(*self.input_shape)
        return dx

    def __backward(self, dout):
        dbeta = dout.sum(axis=0)
        dgamma = np.sum(self.xn * dout, axis=0)
        dxn = self.gamma * dout
        dxc = dxn / self.std
        dstd = -np.sum((dxn * self.xc) / (self.std * self.std), axis=0)
        dvar = 0.5 * dstd / self.std
        dxc += (2.0 / self.batch_size) * self.xc * dvar
        dmu = np.sum(dxc, axis=0)
        dx = dxc - dmu / self.batch_size
        
        self.dgamma = dgamma
        self.dbeta = dbeta
        
        return dx


class Convolution:
    def __init__(self, W, b, stride=1, pad=0):
        self.W = W
        self.b = b
        self.stride = stride
        self.pad = pad

        self.W_int = W
        self.b_int = b

        # 中間データ(backward時に使用)
        self.x = None   
        self.col = None
        self.col_W = None
        self.col_W_int = None
        
        # 重み・バイアスパラメータの勾配
        self.dW = None
        self.db = None

    def forward_int(self, x):
        # wとbをINT8の範囲に修正 2017/06/06 by marsee
        self.W_int = np.array(self.W*COV_WB_MAG+0.5, dtype=int)
        self.b_int = np.array(self.b*COV_WB_MAG+0.5, dtype=int)
        for i in range(self.W_int.shape[0]):
            for j in range(self.W_int.shape[1]):
                for k in range(self.W_int.shape[2]):
                    for m in range(self.W_int.shape[3]):
                        if (self.W_int[i][j][k][m] > COV_WB_MAG*COV_WB_INT/2-1):
                            self.W_int[i][j][k][m] = COV_WB_MAG*COV_WB_INT/2-1
                        elif (self.W_int[i][j][k][m] < -COV_WB_MAG*COV_WB_INT/2):
                            self.W_int[i][j][k][m] = -COV_WB_MAG*COV_WB_INT/2;
        for i in range(self.b_int.shape[0]):
            if (self.b_int[i] > COV_WB_MAG*COV_WB_INT/2-1):
                self.b_int[i] = COV_WB_MAG*COV_WB_INT/2-1
            elif (self.b_int[i] < -COV_WB_MAG*COV_WB_INT/2):
                self.b_int[i] = -COV_WB_MAG*COV_WB_INT/2
        
        self.W_int = np.array(self.W_int, dtype=float)
        self.b_int = np.array(self.b_int, dtype=float)
        
        self.W_int = self.W_int/COV_WB_MAG
        self.b_int = self.b_int/COV_WB_MAG


        FN, C, FH, FW = self.W_int.shape
        N, C, H, W = x.shape
        out_h = 1 + int((H + 2*self.pad - FH) / self.stride)
        out_w = 1 + int((W + 2*self.pad - FW) / self.stride)
       
        col = im2col(x, FH, FW, self.stride, self.pad)
        col_W_int = self.W_int.reshape(FN, -1).T

        out = np.dot(col, col_W_int) + self.b_int

        if (DEBUG == 1):
            print(x.shape)
            print("Conv col.shape = {0}".format(col.shape))
            print("Conv col_W.shape = {0}".format(col_W_int.shape))

            print("Conv np.max(x) = {0}".format(np.max(x)))
            print("Conv np.min(x) = {0}".format(np.min(x)))        
            #print("Conv x = {0}".format(self.x))
            print(self.W_int.shape)
            print("Conv np.max(self.W_int) = {0}".format(np.max(self.W_int)))
            print("Conv np.min(self.W_int) = {0}".format(np.min(self.W_int)))
            print(self.b_int.shape)
            print("Conv np.max(self.b_int) = {0}".format(np.max(self.b_int)))
            print("Conv np.min(self.b_int) = {0}".format(np.min(self.b_int)))
            print("Conv out.shape = {0}".format(out.shape))
            print("Conv np.max(out) = {0}".format(np.max(out)))
            print("Conv np.min(out) = {0}".format(np.min(out)))
            #print("Conv out = {0}".format(out))

        out = np.array(out*COV_OUT_MAG+0.5, dtype=int)
        for i in range(out.shape[0]):
            for j in range(out.shape[1]):
                if (out[i][j] > COV_OUT_MAG*COV_OUT_INT/2-1):
                    out[i][j] = COV_OUT_MAG*COV_OUT_INT/2-1
                elif (out[i][j] < -COV_OUT_MAG*COV_OUT_INT/2):
                    out[i][j] = -COV_OUT_MAG*COV_OUT_INT/2
        out = np.array(out, dtype=float)
        out = out/COV_OUT_MAG

        if (DEBUG == 1):
            print("Conv np.max(out2) = {0}".format(np.max(out)))
            print("Conv np.min(out2) = {0}".format(np.min(out)))


        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)

        if (DEBUG == 1):
            print("Conv out.reshape = {0}".format(out.shape))

        self.x = x
        self.col = col
        self.col_W_int = col_W_int

        return out

    def forward(self, x):
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        out_h = 1 + int((H + 2*self.pad - FH) / self.stride)
        out_w = 1 + int((W + 2*self.pad - FW) / self.stride)

        col = im2col(x, FH, FW, self.stride, self.pad)
        col_W = self.W.reshape(FN, -1).T

        out = np.dot(col, col_W) + self.b
        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)

        self.x = x
        self.col = col
        self.col_W = col_W

        return out

    def forward_msg(self, x):
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        out_h = 1 + int((H + 2*self.pad - FH) / self.stride)
        out_w = 1 + int((W + 2*self.pad - FW) / self.stride)

        col = im2col(x, FH, FW, self.stride, self.pad)
        col_W = self.W.reshape(FN, -1).T

        out = np.dot(col, col_W) + self.b

        print(x.shape)
        print("Conv col.shape = {0}".format(col.shape))
        print("Conv col_W.shape = {0}".format(col_W.shape))

        print("Conv np.max(x) = {0}".format(np.max(x)))
        print("Conv np.min(x) = {0}".format(np.min(x)))        
        #print("Conv x = {0}".format(self.x))
        print(self.W.shape)
        print("Conv np.max(self.W) = {0}".format(np.max(self.W)))
        print("Conv np.min(self.W) = {0}".format(np.min(self.W)))
        print(self.b.shape)
        print("Conv np.max(self.b) = {0}".format(np.max(self.b)))
        print("Conv np.min(self.b) = {0}".format(np.min(self.b)))
        print("Conv out.shape = {0}".format(out.shape))
        print("Conv np.max(out) = {0}".format(np.max(out)))
        print("Conv np.min(out) = {0}".format(np.min(out)))
        #print("Conv out = {0}".format(out))
        print("Conv np.max(out2) = {0}".format(np.max(out)))
        print("Conv np.min(out2) = {0}".format(np.min(out)))

        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)

        print("Conv out.reshape = {0}".format(out.shape))

        self.x = x
        self.col = col
        self.col_W = col_W

        return out

    def backward(self, dout):
        FN, C, FH, FW = self.W.shape
        dout = dout.transpose(0,2,3,1).reshape(-1, FN)

        self.db = np.sum(dout, axis=0)
        self.dW = np.dot(self.col.T, dout)
        self.dW = self.dW.transpose(1, 0).reshape(FN, C, FH, FW)

        dcol = np.dot(dout, self.col_W.T)
        dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad)

        return dx


class Pooling:
    def __init__(self, pool_h, pool_w, stride=1, pad=0):
        self.pool_h = pool_h
        self.pool_w = pool_w
        self.stride = stride
        self.pad = pad
        
        self.x = None
        self.arg_max = None

    def forward_int(self, x):
        if (DEBUG == 1):
            print("Pooling x.shape = {0}".format(x.shape))

        N, C, H, W = x.shape
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)

        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)

        arg_max = np.argmax(col, axis=1)
        out = np.max(col, axis=1)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)

        self.x = x
        self.arg_max = arg_max

        if (DEBUG == 1):
            print("Pooling out.shape = {0}".format(out.shape))

        return out

    def forward_msg(self, x):
        print("Pooling x.shape = {0}".format(x.shape))

        N, C, H, W = x.shape
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)

        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)

        arg_max = np.argmax(col, axis=1)
        out = np.max(col, axis=1)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)

        self.x = x
        self.arg_max = arg_max

        print("Pooling out.shape = {0}".format(out.shape))

        return out

    def forward(self, x):
        N, C, H, W = x.shape
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)

        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)

        arg_max = np.argmax(col, axis=1)
        out = np.max(col, axis=1)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)

        self.x = x
        self.arg_max = arg_max

        return out

    def backward(self, dout):
        dout = dout.transpose(0, 2, 3, 1)
        
        pool_size = self.pool_h * self.pool_w
        dmax = np.zeros((dout.size, pool_size))
        dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten()
        dmax = dmax.reshape(dout.shape + (pool_size,)) 
        
        dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1)
        dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad)
        
        return dx


simple_convnet_int.py を貼っておく。

# simple_convnet_int.py
# 元になったコードは、https://github.com/oreilly-japan/deep-learning-from-scratch にあります。
# 改変したコードもMITライセンスとします。 2017/06/14 by marsee

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 親ディレクトリのファイルをインポートするための設定
import pickle
import numpy as np
from layers_int import *
#from common.layers import *
from common.gradient import numerical_gradient
from collections import OrderedDict


class SimpleConvNet:
    """単純なConvNet

    conv - relu - pool - affine - relu - affine - softmax
    
    Parameters
    ----------
    input_size : 入力サイズ(MNISTの場合は784)
    hidden_size_list : 隠れ層のニューロンの数のリスト(e.g. [100, 100, 100])
    output_size : 出力サイズ(MNISTの場合は10)
    activation : 'relu' or 'sigmoid'
    weight_init_std : 重みの標準偏差を指定(e.g. 0.01)
        'relu'または'he'を指定した場合は「Heの初期値」を設定
        'sigmoid'または'xavier'を指定した場合は「Xavierの初期値」を設定
    """
    def __init__(self, input_dim=(1, 28, 28), 
                 conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
                 hidden_size=100, output_size=10, weight_init_std=0.01):
        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']
        input_size = input_dim[1]
        conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
        pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))

        # 重みの初期化
        self.params = {}
        self.params['W1'] = weight_init_std * \
                            np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)
        self.params['W2'] = weight_init_std * \
                            np.random.randn(pool_output_size, hidden_size)
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = weight_init_std * \
                            np.random.randn(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)

        # レイヤの生成
        self.layers = OrderedDict()
        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
                                           conv_param['stride'], conv_param['pad'])
        self.layers['Relu1'] = Relu()
        self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['Relu2'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])

        self.last_layer = SoftmaxWithLoss()

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    def predict_msg(self, x):
        for layer in self.layers.values():
            x = layer.forward_msg(x)

        return x

    def predict_int(self, x):
        for layer in self.layers.values():
            x = layer.forward_int(x)

        return x

    def loss(self, x, t):
        """損失関数を求める
        引数のxは入力データ、tは教師ラベル
        """
        y = self.predict(x)
        return self.last_layer.forward(y, t)

    def loss_int(self, x, t):
        """損失関数を求める
        引数のxは入力データ、tは教師ラベル
        """
        y = self.predict_int(x)
        return self.last_layer.forward_int(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        acc = 0.0
        
        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt) 
        
        return acc / x.shape[0]

    def accuracy_msg(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        acc = 0.0
        
        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict_msg(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt) 
        
        return acc / x.shape[0]

    def accuracy_int(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        acc = 0.0
        
        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict_int(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt) 
        
        return acc / x.shape[0]

    def numerical_gradient(self, x, t):
        """勾配を求める(数値微分)

        Parameters
        ----------
        x : 入力データ
        t : 教師ラベル

        Returns
        -------
        各層の勾配を持ったディクショナリ変数
            grads['W1']、grads['W2']、...は各層の重み
            grads['b1']、grads['b2']、...は各層のバイアス
        """
        loss_w = lambda w: self.loss(x, t)

        grads = {}
        for idx in (1, 2, 3):
            grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
            grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])

        return grads

    def gradient(self, x, t):
        """勾配を求める(誤差逆伝搬法)

        Parameters
        ----------
        x : 入力データ
        t : 教師ラベル

        Returns
        -------
        各層の勾配を持ったディクショナリ変数
            grads['W1']、grads['W2']、...は各層の重み
            grads['b1']、grads['b2']、...は各層のバイアス
        """
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 設定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
        grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads
        
    def save_params(self, file_name="params.pkl"):
        params = {}
        for key, val in self.params.items():
            params[key] = val
        with open(file_name, 'wb') as f:
            pickle.dump(params, f)

    def load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, key in enumerate(['Conv1', 'Affine1', 'Affine2']):
            self.layers[key].W = self.params['W' + str(i+1)]
            self.layers[key].b = self.params['b' + str(i+1)]


trainer_int.py は変更しようと思ったが、まだ変更はしていない。
  1. 2017年06月16日 04:42 |
  2. DNN
  3. | トラックバック:0
  4. | コメント:0

コメント

コメントの投稿


管理者にだけ表示を許可する

トラックバック URL
http://marsee101.blog19.fc2.com/tb.php/3830-bf94cfb9
この記事にトラックバックする(FC2ブログユーザー)