def infererence(args):
groups = 8
print('Loading image')
image = Image.open(args.image)
print('Preprocessing')
transformer = get_transformer()
input_data = preprocess(image, transformer)
print('input_data ', input_data.shape)
#conv layer
w = np.load('./data/' + 'module.conv1.weight.npy')
b = np.load('./data/' + 'module.conv1.bias.npy')
conv_layer = Convolution(w, b, stride=2, pad=1)
out = conv_layer.forward(input_data)
#savetxt('./dump/' + 'conv1_out.txt', out)
#max pooling
maxpool_layer = Pooling(3, 3, 2, 1)
out = maxpool_layer.forward(out)
#savetxt('./dump/' + 'maxpool_out.txt', out)
out = stage_shuffle(out, stage2_str, 3, groups)
#savetxt('./dump/' + 'stage2.txt', out)
out = stage_shuffle(out, stage3_str, 7, groups)
#savetxt('./dump/' + 'stage3.txt', out)
out = stage_shuffle(out, stage4_str, 3, groups)
#savetxt('./dump/' + 'stage4.txt', out)
h, w = out.shape[-2:]
avgpool_layer = AVGPooling(h, w, 1, 0)
out = avgpool_layer.forward(out).reshape(1, -1)
w = np.load('./data/' + 'module.fc.weight.npy')
b = np.load('./data/' + 'module.fc.bias.npy')
w = w.transpose(1, 0)
fc_layer = Affine(w, b)
out = fc_layer.forward(out)
softmax_layer = Softmax()
out = softmax_layer.forward(out).reshape(-1)
result = []
with open(args.idx_to_class) as json_file:
json_data = json.load(json_file)
'''
for key in json_data:
print(key, json_data[key])
'''
for i in range(0, 1000):
item = (out[i], json_data[str(i)])
result.append(item)
result = sorted(result, key=lambda item: item[0], reverse=True)
for i in range(0, 10):
print(result[i])
def __init__(self, dim_in=(1, 28, 28),
par={'num_filter': 30, 'size_filter': 5, 'pad': 0, 'stride': 1},
s_hidden=100, s_out=10, std_w_init=0.01):
n_f = par['num_filter']
s_f = par['size_filter']
pad = par['pad']
stride = par['stride']
size_in = dim_in[1]
size_out_conv = int((size_in + 2 * pad - s_f) / stride) + 1
size_out_pool = int(n_f * (size_out_conv / 2) ** 2)
self.params = {}
self.params['W1'] =\
std_w_init * np.random.randn(n_f, dim_in[0], s_f, s_f)
self.params['b1'] = np.zeros(n_f)
self.params['W2'] = std_w_init * np.random.randn(size_out_pool, s_hidden)
self.params['b2'] = np.zeros(s_hidden)
self.params['W3'] = std_w_init * np.random.randn(s_hidden, s_out)
self.params['b3'] = np.zeros(s_out)
self.layers = OrderedDict()
self.layers['Conv'] = Convolution(self.params['W1'], self.params['b1'],
stride, pad)
self.layers['Relu1'] = Relu()
self.layers['Pool'] = Pooling(2, 2, 2)
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
self.layers['Relu'] = Relu()
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
def __init__(self, input_dim=(1, 28, 28), conv_param=None, hidden_size=100,
output_size=10, weight_init_std=0.01, regularizer_lambda=0.1):
# 卷积层的默认参数：默认情况下滤波器个数为30个，大小为5x5，不填充，步长1
if conv_param is None:
conv_param = {'filter_num': 30, 'filter_size': 5, 'pad': 0,
'stride': 1}
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 = int((input_size + 2 * filter_pad - filter_size) /
filter_stride + 1) # 卷积层输出的单个特征图的大小
# 最大池化层的输出大小：池化后保持特征图个数不变，由于使用的是2x2的最大
# 池化层，因此宽/高都变为原来的一半。
# 总的输出元素个数为：特征图个数 * (卷积层输出 / 2) * (卷积层输出 / 2)
# 因为这里的简单CNN中池化层后面接全连接层，
# 需要将池化层的节点拉平成一个一维数组
pool_output_size = int(filter_num * (conv_output_size / 2) ** 2)
self.regularizer_lambda = regularizer_lambda # 正则化强度
# 初始化神经网络各层的参数：卷积层、(池化层)、全连接层、全连接层
# 其中池化层没有需要训练的参数，因此不需要初始化。
self.params = {}
# 第一层(卷积层)：滤波器的参数(权重参数) + 偏置参数
# 滤波器的参数有4个：滤波器个数、通道数、高、宽
self.params['W1'] = weight_init_std * np.random.randn(filter_num,
input_dim[0],
filter_size,
filter_size)
# 卷积层的偏置参数：一个滤波器需要一个偏置，因此一共filter_num个偏置
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)
# 构造神经网络：
# 卷积层、激活层(ReLU层)、最大池化层、
# 仿射层(隐藏层)、激活层(ReLU层)、仿射层(输出层)
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'])
# 最后加入一层SoftmaxWithLoss层用于计算交叉熵误差，帮助训练神经网络
self.last_layer = SoftmaxWithLoss()
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):
"""인스턴스 초기화 - CNN 구성, 변수들 초기화
input_dim: 입력 데이터 차원. MNIST인 경우 (1, 28, 28)
conv_param: Convolution 레이어의 파라미터(filter, bias)를 생성하기 위해
필요한 값들
필터 개수(filter_num),
필터 크기(filter_size = filter_height = filter_width),
패딩 개수(pad),
보폭(stride)
hidden_size: Affine 계층에서 사용할 뉴런의 개수 -> W 행렬의 크기
output_size: 출력값의 원소의 개수. MNIST인 경우 10
weight_init_std: 가중치(weight) 행렬을 난수로 초기화할 때 사용할 표준편차
"""
# CNN layer(계층) 생성, 연결
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(W1, b1)
# CNN layer에서 필요한 파라미터들
self.params = dict()
self.params['W1'] = W1
self.params['b1'] = b1
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 = {'W1': weight_init_std * \
np.random.randn(filter_num, input_dim[0], filter_size, filter_size),
'b1': np.zeros(filter_num), 'W2': weight_init_std * \
np.random.randn(pool_output_size, hidden_size),
'b2': np.zeros(hidden_size), 'W3': weight_init_std * \
np.random.randn(hidden_size, output_size),
'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 __init__(self, input_dim = (1, 28, 28),
conv_params = {'filter_num':30,'filter_size': 5, 'pad': 0, 'stride':1},
hidden_size = 100, output_size = 10, weight_init_std = 0.01):
""" 인스턴스 초기화 (변수들의 초기값을 줌) - CNN 구성, 변수들 초기화
input_dim: 입력 데이터 차원, MINIST인 경우(1, 28, 28)
conv_param: Convolution 레이어의 파라미터(filter, bias)를 생성하기 위해 필요한 값들
필터 개수 (filter_num),
필터 크기(filter_size = filter_height = filter_width),
패딩 개수(pad),
보폭(stride)
hidden_size: Affine 계층에서 사용할 뉴런의 개수 -> W 행렬의 크기
output_size: 출력값의 원소의 개수. MNIST인 경우 10
weight_init_std: 가중치(weight) 행렬을 난수로 초기화 할 때 사용할 표준편차
"""
filter_num = conv_params['filter_num']
filter_size = conv_params['filter_size']
filter_pad = conv_params['pad']
filter_stride = conv_params['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))
# CNN Layer에서 필요한 파라미터들
self.params = dict()
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['W'] = weight_init_std * np.random.randn(hidden_size, output_size)
self.params['b3'] = np.zeros(output_size)
# CNN Layer(계층) 생성, 연결
self.layers = OrderedDict()
# 방법 1 __init__(self,W,b) 라고 주고, self.W = W, self.b = b 를 선언
# self.W = W # 난수로 생성하려고 해도 데이터의 크기(size)를 알아야 필터를 생성할 수 있다
# self.b = b # bias의 크기는 필터의 크기와 같다. 마찬가지로 난수로 생성해도 크기를 알아야한다 => dimension 결정
# 방법 2
# input_dim = (1, 28, 28) = MNIST를 위한 클래스
# dimension을 주도록 설정 + 필터갯수가 있도록 설정해줘야한다
# convolution 할 때 필터를 몇번 만들 것인가 -> 난수로 만들어서 넣어줄 수 있다
# key값
self.layers['Conv1'] = Convolution(self.params['W1'],
self.params['b1'],
conv_params['stride'],
conv_params['pad']) # W와 b를 선언
self.layers['ReLu1'] = Relu() # x -> Convolution에서 전해주는 값
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 __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):
'''
인스턴스 초기화 - CNN 구성, 변수들 초기화
input_dim: 입력 데이터 차원. MNIST인 경우 (1, 28, 28)
conv_param: Convolution 레이어의 파라미터(filter, bias)를 생성하기 위해
필요한 값들
필터 개수(filter_num),
필터 크기(filter_size = filter_height = filter_width),
패딩 개수(pad),
보폭(stride)
hidden_size: Affine 계층에서 사용할 뉴런의 개수
output_size: 출력값의 원소의 개수. MNIST인 경우 10
weight_init_std: 가중치(weight) 행렬을 난수로 초기화할 때 사용할 표준편차
'''
c, h, w = input_dim
fn, fh, fw = conv_param['filter_num'], conv_param[
'filter_size'], conv_param['filter_size']
s, p = conv_param['stride'], conv_param['pad']
oh = (h - fh + 2 * p) // s + 1
ow = (w - fw + 2 * p) // s + 1
W1 = np.random.randn(fn, c, fh, fw)
b1 = np.zeros(shape=(fn, ))
# CNN layer(계층) 생성, 연결
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(W1, b1)
# CNN layer 에서 필요한 파라미터들
self.params = dict()
self.params['W1'] = W1
self.params['b1'] = b1
def predict(self):
pass
def loss(self):
pass
def accuracy(self):
pass
def gradient(self):
pass
def make_layers(self):
# レイヤの生成
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(
self.params['W1'], self.params['b1'], 1,
0) # W1が畳み込みフィルタの重み, b1が畳み込みフィルタのバイアスになる
self.layers['ReLU1'] = ReLU()
self.layers['Pool1'] = MaxPooling(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 __init__(self, input_dim=(1, 28, 28),
conv_param_1={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
conv_param_2={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
conv_param_3={'filter_num': 32, 'filter_size': 3, 'pad': 1, 'stride': 1},
conv_param_4={'filter_num': 32, 'filter_size': 3, 'pad': 2, 'stride': 1},
conv_param_5={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
conv_param_6={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
hidden_size=50, output_size=10):
pre_node_nums = np.array([1*3*3, 16*3*3, 16*3*3, 32*3*3, 32*3*3, 64*3*3, 64*4*4, hidden_size])
weight_init_scale = np.sqrt(2.0 / pre_node_nums)
# weights init
self.params = {}
pre_channel_num = input_dim[0]
for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3,
conv_param_4, conv_param_5, conv_param_6]):
self.params['w'+str(idx+1)] = weight_init_scale[idx] *\
np.random.randn(
conv_param['filter_num'],
pre_channel_num, conv_param['filter_size'],
conv_param['filter_size'])
self.params['b'+str(idx+1)] = np.zeros(conv_param['filter_num'])
pre_channel_num = conv_param['filter_num']
self.params['w7'] = weight_init_scale[6] * np.random.randn(64*4*4, hidden_size)
self.params['b7'] = np.zeros(hidden_size)
self.params['w8'] = weight_init_scale[7] * np.random.randn(hidden_size, output_size)
self.params['b8'] = np.zeros(output_size)
# gen layers
self.layers = []
self.layers.append(Convolution(self.params['w1'], self.params['b1'], conv_param_1['stride'],
conv_param_1['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['w2'], self.params['b2'], conv_param_2['stride'],
conv_param_2['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Convolution(self.params['w3'], self.params['b3'], conv_param_3['stride'],
conv_param_3['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['w4'], self.params['b4'], conv_param_4['stride'],
conv_param_4['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Convolution(self.params['w5'], self.params['b5'], conv_param_5['stride'],
conv_param_5['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['w6'], self.params['b6'], conv_param_6['stride'],
conv_param_6['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Affine(self.params['w7'], self.params['b7']))
self.layers.append(Relu())
self.layers.append(Dropout(0.5))
self.layers.append(Affine(self.params['w8'], self.params['b8']))
self.layers.append(Dropout(0.5))
self.last_layer = SoftmaxWithLoss()
def __init__(self, input_dim=(1, 28, 28),
conv_param_1 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
conv_param_2 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
conv_param_3 = {'filter_num':32, 'filter_size':3, 'pad':1, 'stride':1},
conv_param_4 = {'filter_num':32, 'filter_size':3, 'pad':2, 'stride':1},
conv_param_5 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
conv_param_6 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
hidden_size=50, output_size=10):
# 重みの初期化===========
# 各層のニューロンひとつあたりが、前層のニューロンといくつのつながりがあるか（TODO:自動で計算する）
pre_node_nums = np.array([1*3*3, 16*3*3, 16*3*3, 32*3*3, 32*3*3, 64*3*3, 64*4*4, hidden_size])
weight_init_scales = np.sqrt(2.0 / pre_node_nums) # ReLUを使う場合に推奨される初期値
self.params = {}
pre_channel_num = input_dim[0]
for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3, conv_param_4, conv_param_5, conv_param_6]):
self.params['W' + str(idx+1)] = weight_init_scales[idx] * np.random.randn(conv_param['filter_num'], pre_channel_num, conv_param['filter_size'], conv_param['filter_size'])
self.params['b' + str(idx+1)] = np.zeros(conv_param['filter_num'])
pre_channel_num = conv_param['filter_num']
self.params['W7'] = weight_init_scales[6] * np.random.randn(64*4*4, hidden_size)
self.params['b7'] = np.zeros(hidden_size)
self.params['W8'] = weight_init_scales[7] * np.random.randn(hidden_size, output_size)
self.params['b8'] = np.zeros(output_size)
# レイヤの生成===========
self.layers = []
self.layers.append(Convolution(self.params['W1'], self.params['b1'],
conv_param_1['stride'], conv_param_1['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['W2'], self.params['b2'],
conv_param_2['stride'], conv_param_2['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Convolution(self.params['W3'], self.params['b3'],
conv_param_3['stride'], conv_param_3['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['W4'], self.params['b4'],
conv_param_4['stride'], conv_param_4['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Convolution(self.params['W5'], self.params['b5'],
conv_param_5['stride'], conv_param_5['pad']))
self.layers.append(Relu())
self.layers.append(Convolution(self.params['W6'], self.params['b6'],
conv_param_6['stride'], conv_param_6['pad']))
self.layers.append(Relu())
self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
self.layers.append(Affine(self.params['W7'], self.params['b7']))
self.layers.append(Relu())
self.layers.append(Dropout(0.5))
self.layers.append(Affine(self.params['W8'], self.params['b8']))
self.layers.append(Dropout(0.5))
self.last_layer = SoftmaxWithLoss()
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))
""" 인스턴스 초기화 - CNN 구성, 변수들 초기화"""
# CNN layer에서 필요한 파라미터들
self.params = dict()
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)
# CNN layer(계층) 생성, 연결
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['Relu2'] = Relu()
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
def stage_shuffle(input_data, stage, repeat_num, groups):
avgpool_layer = AVGPooling(3, 3, 2, 1)
residual = avgpool_layer.forward(input_data)
#savetxt('./dump/' + 'avg_pool.txt', residual)
w = np.load(stage + '0.g_conv_1x1_compress.conv1x1.weight.npy')
b = np.load(stage + '0.g_conv_1x1_compress.conv1x1.bias.npy')
if 'Stage2' in stage:
conv_layer = Convolution(w, b, stride=1, pad=0)
else:
conv_layer = GroupConvolution(w, b, stride=1, pad=0, groups=groups)
out = conv_layer.forward(input_data)
out_N, out_C, out_H, out_W = out.shape
gamma = np.load(stage +
'0.g_conv_1x1_compress.batch_norm.weight.npy').reshape(
(-1, 1))
beta = np.load(stage +
'0.g_conv_1x1_compress.batch_norm.bias.npy').reshape(
(-1, 1))
mean = np.load(
stage + '0.g_conv_1x1_compress.batch_norm.running_mean.npy').reshape(
(-1, 1))
var = np.load(stage +
'0.g_conv_1x1_compress.batch_norm.running_var.npy').reshape(
(-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out = bn_layer.forward(out.reshape(out_C, -1), train_flg=False)
relu_layer = Relu()
out = relu_layer.forward(out).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + '1x1_comp.txt', out)
out = channel_shuffle(out, groups)
#savetxt('./dump/' + 'channel_shuffle.txt', out)
w = np.load(stage + '0.depthwise_conv3x3.weight.npy').transpose(1, 0, 2, 3)
b = np.load(stage + '0.depthwise_conv3x3.bias.npy')
dwconv_layer = DWConvolution(w, b, stride=2, pad=1)
out = dwconv_layer.forward(out)
#savetxt('./dump/' + 'dwconv.txt', out)
gamma = np.load(stage + '0.bn_after_depthwise.weight.npy').reshape((-1, 1))
beta = np.load(stage + '0.bn_after_depthwise.bias.npy').reshape((-1, 1))
mean = np.load(stage + '0.bn_after_depthwise.running_mean.npy').reshape(
(-1, 1))
var = np.load(stage + '0.bn_after_depthwise.running_var.npy').reshape(
(-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out_N, out_C, out_H, out_W = out.shape
out = bn_layer.forward(out.reshape(out_C, -1),
train_flg=False).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + 'after_bn.txt', out)
w = np.load(stage + '0.g_conv_1x1_expand.conv1x1.weight.npy')
b = np.load(stage + '0.g_conv_1x1_expand.conv1x1.bias.npy')
groupconv_layer = GroupConvolution(w, b, stride=1, pad=0, groups=groups)
out = groupconv_layer.forward(out)
gamma = np.load(stage +
'0.g_conv_1x1_expand.batch_norm.weight.npy').reshape(
(-1, 1))
beta = np.load(stage + '0.g_conv_1x1_expand.batch_norm.bias.npy').reshape(
(-1, 1))
mean = np.load(stage +
'0.g_conv_1x1_expand.batch_norm.running_mean.npy').reshape(
(-1, 1))
var = np.load(stage +
'0.g_conv_1x1_expand.batch_norm.running_var.npy').reshape(
(-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out_N, out_C, out_H, out_W = out.shape
out = bn_layer.forward(out.reshape(out_C, -1),
train_flg=False).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + 'gconv.txt', out)
out = np.concatenate((residual, out), 1)
#savetxt('./dump/' + 'combine.txt', out)
relu_layer = Relu()
out_N, out_C, out_H, out_W = out.shape
out = relu_layer.forward(out).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + 'stage2.txt', out)
for i in range(1, repeat_num + 1):
residual = out
w = np.load(stage + str(i) + '.g_conv_1x1_compress.conv1x1.weight.npy')
b = np.load(stage + str(i) + '.g_conv_1x1_compress.conv1x1.bias.npy')
groupconv_layer = GroupConvolution(w,
b,
stride=1,
pad=0,
groups=groups)
out = groupconv_layer.forward(out)
out_N, out_C, out_H, out_W = out.shape
gamma = np.load(stage + str(i) +
'.g_conv_1x1_compress.batch_norm.weight.npy').reshape(
(-1, 1))
beta = np.load(stage + str(i) +
'.g_conv_1x1_compress.batch_norm.bias.npy').reshape(
(-1, 1))
mean = np.load(
stage + str(i) +
'.g_conv_1x1_compress.batch_norm.running_mean.npy').reshape(
(-1, 1))
var = np.load(
stage + str(i) +
'.g_conv_1x1_compress.batch_norm.running_var.npy').reshape((-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out = bn_layer.forward(out.reshape(out_C, -1), train_flg=False)
relu_layer = Relu()
out = relu_layer.forward(out).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + str(i) + '_1x1_comp.txt', out)
out = channel_shuffle(out, groups)
#savetxt('./dump/' + 'channel_shuffle.txt', out)
w = np.load(stage + str(i) +
'.depthwise_conv3x3.weight.npy').transpose(1, 0, 2, 3)
b = np.load(stage + str(i) + '.depthwise_conv3x3.bias.npy')
dwconv_layer = DWConvolution(w, b, stride=1, pad=1)
out = dwconv_layer.forward(out)
#savetxt('./dump/' + 'dwconv.txt', out)
gamma = np.load(stage + str(i) +
'.bn_after_depthwise.weight.npy').reshape((-1, 1))
beta = np.load(stage + str(i) +
'.bn_after_depthwise.bias.npy').reshape((-1, 1))
mean = np.load(stage + str(i) +
'.bn_after_depthwise.running_mean.npy').reshape((-1, 1))
var = np.load(stage + str(i) +
'.bn_after_depthwise.running_var.npy').reshape((-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out_N, out_C, out_H, out_W = out.shape
out = bn_layer.forward(out.reshape(out_C, -1),
train_flg=False).reshape(
out_N, out_C, out_H, out_W)
#savetxt('./dump/' + 'after_bn.txt', out)
w = np.load(stage + str(i) + '.g_conv_1x1_expand.conv1x1.weight.npy')
b = np.load(stage + str(i) + '.g_conv_1x1_expand.conv1x1.bias.npy')
groupconv_layer = GroupConvolution(w,
b,
stride=1,
pad=0,
groups=groups)
out = groupconv_layer.forward(out)
gamma = np.load(stage + str(i) +
'.g_conv_1x1_expand.batch_norm.weight.npy').reshape(
(-1, 1))
beta = np.load(stage + str(i) +
'.g_conv_1x1_expand.batch_norm.bias.npy').reshape(
(-1, 1))
mean = np.load(
stage + str(i) +
'.g_conv_1x1_expand.batch_norm.running_mean.npy').reshape((-1, 1))
var = np.load(stage + str(i) +
'.g_conv_1x1_expand.batch_norm.running_var.npy').reshape(
(-1, 1))
bn_layer = BatchNormalization(gamma,
beta,
running_mean=mean,
running_var=var)
out_N, out_C, out_H, out_W = out.shape
out = bn_layer.forward(out.reshape(out_C, -1),
train_flg=False).reshape(
out_N, out_C, out_H, out_W)
#savetxt('./dump/' + 'gconv.txt', out)
out = np.add(residual, out)
#savetxt('./dump/' + str(i) + '_combine.txt', out)
relu_layer = Relu()
out_N, out_C, out_H, out_W = out.shape
out = relu_layer.forward(out).reshape(out_N, out_C, out_H, out_W)
#savetxt('./dump/' + str(i) + '_stage.txt', out)
return out
network = SimpleConvNet(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)
# 学習後の重み
network.load_params("params.pkl")
filter_show(network.params['W1'], 16)
img = imread('../dataset/lena_gray.png')
img = img.reshape(1, 1, *img.shape)
fig = plt.figure()
w_idx = 1
for i in range(16):
w = network.params['W1'][i]
b = 0 # network.params['b1'][i]
w = w.reshape(1, *w.shape)
#b = b.reshape(1, *b.shape)
conv_layer = Convolution(w, b)
out = conv_layer.forward(img)
out = out.reshape(out.shape[2], out.shape[3])
ax = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])
ax.imshow(out, cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
},
hidden_size=100,
output_size=10,
weight_init_std=0.01)
# 学习后的权重
network.load_params("params.pkl")
filter_show(network.params['W1'], 16)
img = imread('../dataset/lena_gray.png')
img = img.reshape(1, 1, *img.shape)
fig = plt.figure()
w_idx = 1
for i in range(16):
w = network.params['W1'][i]
b = 0 # network.params['b1'][i]
w = w.reshape(1, *w.shape)
#b = b.reshape(1, *b.shape)
conv_layer = Convolution(w, b)
out = conv_layer.forward(img)
out = out.reshape(out.shape[2], out.shape[3])
ax = fig.add_subplot(4, 4, i + 1, xticks=[], yticks=[])
ax.imshow(out, cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
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,
weight_decay_lambda=0.01):
"""
input_size : 入力の配列形状(チャンネル数、画像の高さ、画像の幅)
conv_param : 畳み込みの条件, dict形式 例、{'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1}
hidden_size : 隠れ層のノード数
output_size : 出力層のノード数
weight_init_std ： 重みWを初期化する際に用いる標準偏差
"""
self.hidden_layer_num = 3
self.weight_decay_lambda = weight_decay_lambda
#filter_num = conv_param['filter_num']
#filter_size = conv_param['filter_size']
#filter_pad = conv_param['pad']
#filter_stride = conv_param['stride']
filter_num = 30
filter_size = 5
filter_pad = 0
filter_stride = 1
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 = {}
std = weight_init_std
self.params['W1'] = std * np.random.randn(
filter_num, input_dim[0], filter_size,
filter_size) # W1は畳み込みフィルターの重みになる
self.params['b1'] = np.zeros(filter_num) #b1は畳み込みフィルターのバイアスになる
#self.params['W2'] = std * np.random.randn(pool_output_size, hidden_size)
self.params['b2'] = np.zeros(hidden_size)
#self.params['W3'] = std * np.random.randn(hidden_size, output_size)
self.params['b3'] = np.zeros(output_size)
#Heの初期値を使用
self.params['W2'] = np.random.randn(pool_output_size,
hidden_size) * he(pool_output_size)
self.params['W3'] = np.random.randn(hidden_size,
output_size) * he(hidden_size)
# レイヤの生成
self.layers = OrderedDict()
#self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
# conv_param['stride'], conv_param['pad']) # W1が畳み込みフィルターの重み, b1が畳み込みフィルターのバイアスになる
self.layers['Conv1'] = Convolution(
self.params['W1'], self.params['b1'], 1,
0) # W1が畳み込みフィルターの重み, b1が畳み込みフィルターのバイアスになる
self.layers['ReLU1'] = ReLU()
self.layers['Pool1'] = MaxPooling(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 __init__(self,
input_dim=(1, 28, 28),
conv_param_1=None,
conv_param_2=None,
conv_param_3=None,
conv_param_4=None,
conv_param_5=None,
conv_param_6=None,
hidden_size=50,
output_size=10):
# 第一个卷积层输入1x28x28，输出16x28x28
if conv_param_1 is None:
conv_param_1 = {
'filter_num': 16,
'filter_size': 3,
'pad': 1,
'stride': 1
}
# 第二个卷积层输入16x28x28，输出16x28x28
if conv_param_2 is None:
conv_param_2 = {
'filter_num': 16,
'filter_size': 3,
'pad': 1,
'stride': 1
}
# 第二个卷积层之后接最大池化层，池化层大小为2x2,步长为2，即高、宽减半
# 第三个卷积层输入16x14x14，输出32x14x14
if conv_param_3 is None:
conv_param_3 = {
'filter_num': 32,
'filter_size': 3,
'pad': 1,
'stride': 1
}
# 第四个卷积层输入32x14x14，但由于pad2个，因此输出32x16x16
if conv_param_4 is None:
conv_param_4 = {
'filter_num': 32,
'filter_size': 3,
'pad': 2,
'stride': 1
}
# 第四个卷积层之后接最大池化层，池化层大小为2x2,步长为2，即高、宽减半
# 第五个卷积层输入32x8x8，输出64x8x8
if conv_param_5 is None:
conv_param_5 = {
'filter_num': 64,
'filter_size': 3,
'pad': 1,
'stride': 1
}
# 第五个卷积层输入64x8x8，输出64x8x8
if conv_param_6 is None:
conv_param_6 = {
'filter_num': 64,
'filter_size': 3,
'pad': 1,
'stride': 1
}
"""
卷积层的每个节点只与前一层的filter_size个节点连接，
即本层卷积层的卷积核 高x宽有多少，就和前一层的多少个节点连接。
如果有多个通道，那还要乘上通道数(深度)
这里的所有卷积层都用3x3的大小
各层输出如下：
卷积层1： 16 28 28
卷积层2 | 池化层1： 16 28 28 | 16 14 14
卷积层3： 32 14 14
卷积层4 | 池化层2： 32 16 16 | 32 8 8
卷积层5： 64 8 8
卷积层6： 64 8 8 | 64 4 4
"""
pre_node_nums = np.array([
1 * 3 * 3, # 卷积层1：前一层(输入层)通道数(深度)为1
16 * 3 * 3, # 卷积层2：前一层(卷积层1)通道数(深度)为16
16 * 3 * 3, # 卷积层3：前一层(卷积层2)通道数(深度)为16
32 * 3 * 3, # 卷积层4：前一层(卷积层3)通道数(深度)为32
32 * 3 * 3, # 卷积层5：前一层(卷积层4)通道数(深度)为32
64 * 3 * 3, # 卷积层6：前一层(卷积层5)通道数(深度)为64
# 隐藏层：前一层(池化层)，池化层接全连接层需要拉直成一维数组，
# 因此隐藏层与前一层(池化层)的连接数为池化层的输出节点总数
64 * 4 * 4,
# 输出层：前一层(隐藏层)，全连接与前一层全部节点相连，即隐藏层大小
hidden_size
])
# 权重初始化时的标准差。由于使用ReLU激活函数，因此使用He初始化方式
weight_init_scales = np.sqrt(2.0 / pre_node_nums)
"""初始化权重参数和偏置"""
self.params = {}
pre_channel_num = input_dim[0] # 记录上一层的通道数(即滤波器的通道数)
for idx, conv_param in enumerate([
conv_param_1, conv_param_2, conv_param_3, conv_param_4,
conv_param_5, conv_param_6
]):
# 卷积层滤波器的形状：滤波器个数、通道数、高度、宽度
self.params['W'+str(idx+1)] = weight_init_scales[idx] *\
np.random.randn(
conv_param['filter_num'],
pre_channel_num,
conv_param['filter_size'],
conv_param['filter_size'])
self.params['b' + str(idx + 1)] = np.zeros(
conv_param['filter_num'])
pre_channel_num = conv_param['filter_num'] # 更新上一层的通道数
self.params['W7'] = weight_init_scales[6] * np.random.randn(
64 * 4 * 4, hidden_size)
self.params['b7'] = np.zeros(hidden_size)
self.params['W8'] = weight_init_scales[7] * np.random.randn(
hidden_size, output_size)
self.params['b8'] = np.zeros(output_size)
"""
构造神经网络：
书上没有用到之前用的有序字典，其实我觉得很好用，所以就实现了有序字典版本
Conv1->ReLU1->Conv2->ReLU2->Pool1->
Conv3->ReLU3->Conv4->ReLU4->Pool2->
Conv5->ReLU5->Conv6->ReLU6->Pool3->
Affine1(Hidden Layer1)->ReLU7->Dropout1->
Affine2(Output Layer1)->Dropout2------->SoftmaxWithLoss
"""
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(self.params['W1'],
self.params['b1'],
stride=conv_param_1['stride'],
pad=conv_param_1['pad'])
self.layers['ReLU1'] = ReLU()
self.layers['Conv2'] = Convolution(self.params['W2'],
self.params['b2'],
stride=conv_param_2['stride'],
pad=conv_param_2['pad'])
self.layers['ReLU2'] = ReLU()
self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2, pad=0)
self.layers['Conv3'] = Convolution(self.params['W3'],
self.params['b3'],
stride=conv_param_3['stride'],
pad=conv_param_3['pad'])
self.layers['ReLU3'] = ReLU()
self.layers['Conv4'] = Convolution(self.params['W4'],
self.params['b4'],
stride=conv_param_4['stride'],
pad=conv_param_4['pad'])
self.layers['ReLU4'] = ReLU()
self.layers['Pool2'] = Pooling(pool_h=2, pool_w=2, stride=2, pad=0)
self.layers['Conv5'] = Convolution(self.params['W5'],
self.params['b5'],
stride=conv_param_5['stride'],
pad=conv_param_5['pad'])
self.layers['ReLU5'] = ReLU()
self.layers['Conv6'] = Convolution(self.params['W6'],
self.params['b6'],
stride=conv_param_6['stride'],
pad=conv_param_6['pad'])
self.layers['ReLU6'] = ReLU()
self.layers['Pool3'] = Pooling(pool_h=2, pool_w=2, stride=2, pad=0)
self.layers['Affine1'] = Affine(self.params['W7'], self.params['b7'])
self.layers['ReLU7'] = ReLU()
self.layers['Dropout1'] = Dropout(dropout_ratio=0.5)
self.layers['Affine2'] = Affine(self.params['W8'], self.params['b8'])
self.layers['Dropout2'] = Dropout(dropout_ratio=0.5)
self.last_layer = SoftmaxWithLoss()
# pickle 파일에 저장된 파라미터를 cnn의 필드로 로드
cnn.load_params('cnn_params.pkl')
after_filters = cnn.params['W1']
# 학습 끝난 후 갱신(업데이트)된 파라미터를 그래프로 출력
show_filters(after_filters, 16, 4)
# 학습 끝난 후 갱신된 파라미터를 실제 이미지 파일에 적용
lena = plt.imread('lena_gray.png') # imread는 png만 바로 shape으로 적용하게 해준다
# jpg는 PIL를 사용해서 열어야한다
print(lena.shape) #(256, 256) #이미지 파일이 numpy array로 변환됨 -> 2차원
# 이미지 데이터를 convolution layer의 forward()메소드에 전달
# 우리의 convolution 레이어는 오직 4차원만 받음 -> 레나 이미지를 4차원으로 만들어줘야한다
# 2차원 배열을 4차원 배열로 변환
lena = lena.reshape(1, 1, *lena.shape) # *lena.shape = (256, 256)
for i in range(16): # 필터 16개에 대해서 반복
w = cnn.params['W1'][i] # 갱신된 필터w
# b = cnn.params['b1'][i] #갱신된 bias
b = 0 # did not use bias because the image might get distorted
w = w.reshape(1, *w.shape) #3d -> 4d
conv = Convolution(w, b) # convolution 레이어 생성
# 필터 - 학습이 끝난 상태의 필터 (5x5의 작은 필터를 보낸것)
out = conv.forward(lena) #이미지 필터에 적용
# pyplot을 사용하기 위해서 4d-> 2d
out = out.reshape(out.shape[2], out.shape[3])
# subplot에 그림
plt.subplot(4, 4, i + 1, xticks=[], yticks=[])
plt.imshow(out, cmap='gray')
plt.show()
show_filters(before_filters, num_filters=16, ncols=4)
# 학습이 끝난 후 파라미터
cnn.load_params('cnn_params.pkl')
after_filters = cnn.params['W1']
# 학습 끝난 후 갱신된 파라미터 그래프로 출력
show_filters(after_filters, 16, 4)
# 학습 끝난 후 갱신 된 파라미터를 실제 이미지 파일에 적용
lena = plt.imread(
'lena_gray.png'
) # numpy array 로 이미지 열어진다. 단, png 파일만. jpeg 의 경우 외부 패키지 필요
print('lena shape =', lena.shape) # (256, 256) ndarray
# 이미지 데이터를 Convolution 레이어의 forward() 메소드에 전달하기 위해서 2차원 배열을 4차원 배열로 변환
lena = lena.reshape(1, 1, *lena.shape) # * : 튜플 내용을 하나씩 꺼내준다. (256, 256)
print('lena shape =', lena.shape)
for i in range(16): # 필터 16개에 대해 반복
w = cnn.params['W1'][i] # 갱신된 필터
b = 0 # 바이어스 사용 안함
w = w.reshape(1, *w.shape) # 3차원 -> 4차원
conv = Convolution(w, b) # Convolution 레이어 생성
out = conv.forward(lena) # 이미지에 필터 적용
# pyplot 을 사용하기 위해거 4차원을 2차원으로 변환
out = out.reshape(out.shape[2], out.shape[3])
plt.subplot(4, 4, i + 1, xticks=[], yticks=[])
plt.imshow(out, cmap='gray')
plt.show()
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):
"""
input_size : 入力の配列形状(チャンネル数、画像の高さ、画像の幅)
conv_param : 畳み込みの条件, dict形式 例、{'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1}
hidden_size : 隠れ層のノード数
output_size : 出力層のノード数
weight_init_std ： 重みWを初期化する際に用いる標準偏差
"""
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 = {}
std = weight_init_std
self.params['W1_1'] = std * np.random.randn(16, 1, 3,3)
self.params['b1_1'] = np.zeros(16)
self.params['W1_3'] = std * np.random.randn(16, 16, 3,3)
self.params['b1_3'] = np.zeros(16)
self.params['W2_1'] = std * np.random.randn(32, 16, 3,3)
self.params['b2_1'] = np.zeros(32)
self.params['W2_3'] = std * np.random.randn(32, 32, 3,3)
self.params['b2_3'] = np.zeros(32)
self.params['W3_1'] = std * np.random.randn(64, 32, 3,3)
self.params['b3_1'] = np.zeros(64)
self.params['W3_3'] = std * np.random.randn(64, 64, 3,3)
self.params['b3_3'] = np.zeros(64)
self.params['W4_1'] = std * np.random.randn(64*4*4, hidden_size)
self.params['b4_1'] = np.zeros(hidden_size)
self.params['W5_1'] = std * np.random.randn(hidden_size, output_size)
self.params['b5_1'] = np.zeros(output_size)
# レイヤの生成
self.layers = OrderedDict()
self.layers['Conv1_1'] = Convolution(self.params['W1_1'], self.params['b1_1'],1,1)
self.layers['ReLU1_2'] = ReLU()
self.layers['Conv1_3'] = Convolution(self.params['W1_3'], self.params['b1_3'],1,1)
self.layers['ReLU1_4'] = ReLU()
self.layers['Pool1_5'] = MaxPooling(pool_h=2, pool_w=2, stride=2)
self.layers['Conv2_1'] = Convolution(self.params['W2_1'], self.params['b2_1'],1,1)
self.layers['ReLU2_2'] = ReLU()
self.layers['Conv2_3'] = Convolution(self.params['W2_3'], self.params['b2_3'],1,2)
self.layers['ReLU2_4'] = ReLU()
self.layers['Pool2_5'] = MaxPooling(pool_h=2, pool_w=2, stride=2)
self.layers['Conv3_1'] = Convolution(self.params['W3_1'], self.params['b3_1'],1,1)
self.layers['ReLU3_2'] = ReLU()
self.layers['Conv3_3'] = Convolution(self.params['W3_3'], self.params['b3_3'],1,1)
self.layers['ReLU3_4'] = ReLU()
self.layers['Pool3_5'] = MaxPooling(pool_h=2, pool_w=2, stride=2)
self.layers['Affine4_1'] = Affine(self.params['W4_1'], self.params['b4_1'])
self.layers['ReLU4_2'] = ReLU()
self.layers['Dropout4_3'] = Dropout(0.5)
self.layers['Affine5_1'] = Affine(self.params['W5_1'], self.params['b5_1'])
self.layers['Dropout5_2'] = Dropout(0.5)
self.last_layer = SoftmaxWithLoss()
def __init__(self,
input_dim=(1, 28, 28),
use_conv2=True,
use_affine2=True,
conv_param={
'filter_num': 128,
'filter_size': 3,
'pad': 1,
'stride': 1
},
pool_param={
'pool_size': 2,
'pad': 1,
'stride': 2
},
conv_param2={
'filter_num2': 128,
'filter_size2': 3,
'pad2': 1,
'stride2': 1
},
pool_param2={
'pool_size2': 2,
'pad2': 1,
'stride2': 2
},
hidden_size=128,
hidden_size2=128,
output_size=15,
weight_init_std=0.01,
use_batchnorm_C1=False,
use_batchnorm_C2=False,
use_batchnorm_A1=False,
use_batchnorm_A2=False,
use_dropout_A1=False,
dropout_ratio_A1=0.5,
use_dropout_A2=False,
dropout_ratio_A2=0.5,
use_succession=False,
data_num=1,
prediction_mode=False):
filter_num = conv_param['filter_num']
filter_size = conv_param['filter_size']
filter_pad = conv_param['pad']
filter_stride = conv_param['stride']
pool_size = pool_param['pool_size']
pool_pad = pool_param['pad']
pool_stride = pool_param['stride']
filter_num2 = conv_param2['filter_num2']
filter_size2 = conv_param2['filter_size2']
filter_pad2 = conv_param2['pad2']
filter_stride2 = conv_param2['stride2']
pool_size2 = pool_param2['pool_size2']
pool_pad2 = pool_param2['pad2']
pool_stride2 = pool_param2['stride2']
input_size = input_dim[1]
conv_output_size = (input_size + 2 * filter_pad - filter_size
) // filter_stride + 1 # 畳み込み後のサイズ(H,W共通)
pool_output_size = (conv_output_size + 2 * pool_pad -
pool_size) // pool_stride + 1 # プーリング後のサイズ(H,W共通)
pool_output_pixel = filter_num * pool_output_size * pool_output_size # プーリング後のピクセル総数
input_size2 = pool_output_size
conv_output_size2 = (input_size2 + 2 * filter_pad2 - filter_size2
) // filter_stride2 + 1 # 畳み込み後のサイズ(H,W共通)
pool_output_size2 = (conv_output_size2 + 2 * pool_pad2 - pool_size2
) // pool_stride2 + 1 # プーリング後のサイズ(H,W共通)
pool_output_pixel2 = filter_num2 * pool_output_size2 * pool_output_size2 # プーリング後のピクセル総数
self.use_conv2 = use_conv2
self.use_affine2 = use_affine2
self.use_batchnorm_C1 = use_batchnorm_C1
self.use_batchnorm_C2 = use_batchnorm_C2
self.use_batchnorm_A1 = use_batchnorm_A1
self.use_batchnorm_A2 = use_batchnorm_A2
self.use_dropout_A1 = use_dropout_A1
self.use_dropout_A2 = use_dropout_A2
self.dropout_ratio_A1 = dropout_ratio_A1
self.dropout_ratio_A2 = dropout_ratio_A2
self.use_succession = use_succession
self.data_num = data_num
self.prediction_mode = prediction_mode
# if W1 == []:
self.params = {}
self.paramsB = {}
std = weight_init_std
if self.use_succession:
#----------重みをpickleから代入--------------
with open("params_" + str(self.data_num) + ".pickle", "rb") as f:
params_s = pickle.load(f)
with open("params_BN" + str(self.data_num) + ".pickle", "rb") as f:
params_BN = pickle.load(f)
# self.params = {}
# self.paramsB = {}
self.params['W1'] = params_s['W1'] # W1は畳み込みフィルターの重みになる
self.params['b1'] = params_s['b1']
if self.use_batchnorm_C1:
self.paramsB["BC1_moving_mean"] = params_BN["BC1_moving_mean"]
self.paramsB["BC1_moving_var"] = params_BN["BC1_moving_var"]
if self.use_conv2:
self.params['W1_2'] = params_s['W1_2']
self.params['b1_2'] = params_s['b1_2']
if self.use_batchnorm_C2:
self.paramsB["BC2_moving_mean"] = params_BN[
"BC2_moving_mean"]
self.paramsB["BC2_moving_var"] = params_BN[
"BC2_moving_var"]
self.params['W2'] = params_s['W2']
self.params['b2'] = params_s['b2']
if self.use_batchnorm_A1:
self.paramsB["BA1_moving_mean"] = params_BN["BA1_moving_mean"]
self.paramsB["BA1_moving_var"] = params_BN["BA1_moving_var"]
if self.use_affine2:
self.params['W2_2'] = params_s['W2_2']
self.params['b2_2'] = params_s['b2_2']
if self.use_batchnorm_A2:
self.paramsB["BA2_moving_mean"] = params_BN[
"BA2_moving_mean"]
self.paramsB["BA2_moving_var"] = params_BN[
"BA2_moving_var"]
self.params['W3'] = params_s['W3']
self.params['b3'] = params_s['b3']
#----------重みをpickleから代入--------------
else:
# 重みの初期化
#----第１層Conv----
self.params['W1'] = std * np.random.randn(
filter_num, input_dim[0], filter_size,
filter_size) # W1は畳み込みフィルターの重みになる
self.params['b1'] = np.zeros(filter_num) #b1は畳み込みフィルターのバイアスになる
#----第２層Conv----
if self.use_conv2:
self.params['W1_2'] = std * np.random.randn(
filter_num2, filter_num, filter_size2,
filter_size2) #-----追加------
self.params['b1_2'] = np.zeros(filter_num2) #-----追加------
#----第３層Affine----
self.params['W2'] = std * np.random.randn(
pool_output_pixel2, hidden_size)
else:
self.params['W2'] = std * np.random.randn(
pool_output_pixel, hidden_size)
self.params['b2'] = np.zeros(hidden_size)
#----第４層Affine----
if self.use_affine2:
self.params['W2_2'] = std * np.random.randn(
hidden_size, hidden_size2) #-----追加------
self.params['b2_2'] = np.zeros(hidden_size2) #-----追加------
#----第５層出力----
self.params['W3'] = std * np.random.randn(
hidden_size2, output_size) #--変更--
else:
self.params['W3'] = std * np.random.randn(
hidden_size, output_size) #--変更--
self.params['b3'] = np.zeros(output_size)
# レイヤの生成
self.layers = OrderedDict()
#----第１層Conv----
self.layers['Conv1'] = Convolution(
self.params['W1'], self.params['b1'], conv_param['stride'],
conv_param['pad']) # W1が畳み込みフィルターの重み, b1が畳み込みフィルターのバイアスになる
if self.use_batchnorm_C1:
print(conv_output_size)
print(conv_output_size ^ 2)
batch_num = conv_output_size * conv_output_size
if self.prediction_mode:
self.layers['BatchNormalization_C1'] = BatchNormalization(
np.ones(batch_num, filter_num),
np.zeros(filter_num),
moving_mean=self.paramsB["BC1_moving_mean"],
moving_var=self.paramsB["BC1_moving_var"])
else:
self.layers['BatchNormalization_C1'] = BatchNormalization(
np.ones(batch_num),
np.zeros(batch_num),
DataNum=self.data_num,
LayerNum="C1")
self.paramsB["BC1_moving_mean"] = self.layers[
'BatchNormalization_C1'].moving_mean
self.paramsB["BC1_moving_var"] = self.layers[
'BatchNormalization_C1'].moving_var
self.layers['ReLU1'] = ReLU()
self.layers['Pool1'] = MaxPooling(pool_h=pool_size,
pool_w=pool_size,
stride=pool_stride,
pad=pool_pad)
#----第２層Conv----
if self.use_conv2:
self.layers['Conv1_2'] = Convolution(
self.params['W1_2'], self.params['b1_2'],
conv_param2['stride2'], conv_param2['pad2']) #-----追加------
if self.use_batchnorm_C2:
batch_num2 = conv_output_size2 * conv_output_size2 * filter_num2
if self.prediction_mode:
self.layers['BatchNormalization_C2'] = BatchNormalization(
np.ones(batch_num),
np.zeros(batch_num),
moving_mean=self.paramsB["BC2_moving_mean"],
moving_var=self.paramsB["BC12moving_var"])
else:
self.layers['BatchNormalization_C2'] = BatchNormalization(
np.ones(batch_num),
np.zeros(batch_num),
DataNum=self.data_num,
LayerNum="C2")
self.paramsB["BC2_moving_mean"] = self.layers[
'BatchNormalization_C2'].moving_mean
self.paramsB["BC2_moving_var"] = self.layers[
'BatchNormalization_C2'].moving_var
self.layers['ReLU1_2'] = ReLU() #-----追加------
self.layers['Pool1_2'] = MaxPooling(pool_h=pool_size2,
pool_w=pool_size2,
stride=pool_stride2,
pad=pool_pad2) #-----追加------
#----第３層Affine----
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
if self.use_batchnorm_A1:
if self.prediction_mode:
self.layers['BatchNormalization_A1'] = BatchNormalization(
np.ones(hidden_size),
np.zeros(hidden_size),
moving_mean=self.paramsB["BA1_moving_mean"],
moving_var=self.paramsB["BA1_moving_var"])
else:
self.layers['BatchNormalization_A1'] = BatchNormalization(
np.ones(hidden_size),
np.zeros(hidden_size),
DataNum=self.data_num,
LayerNum="A1")
self.paramsB["BA1_moving_mean"] = self.layers[
'BatchNormalization_A1'].moving_mean
self.paramsB["BA1_moving_var"] = self.layers[
'BatchNormalization_A1'].moving_var
if self.use_dropout_A1:
self.layers['DropoutA1'] = Dropout(self.dropout_ratio_A1)
self.layers['ReLU2'] = ReLU()
# ----第４層Affine----
if self.use_affine2:
self.layers['Affine2'] = Affine(
self.params['W2_2'], self.params['b2_2']) #-----追加------
if self.use_batchnorm_A2:
if self.prediction_mode:
self.layers['BatchNormalization_A2'] = BatchNormalization(
np.ones(hidden_size2),
np.zeros(hidden_size2),
moving_mean=self.paramsB["BA2_moving_mean"],
moving_var=self.paramsB["BA2_moving_var"])
else:
self.layers['BatchNormalization_A2'] = BatchNormalization(
np.ones(hidden_size2),
np.zeros(hidden_size2),
DataNum=self.data_num,
LayerNum="A2")
self.paramsB["BA2_moving_mean"] = self.layers[
'BatchNormalization_A2'].moving_mean
self.paramsB["BA2_moving_var"] = self.layers[
'BatchNormalization_A2'].moving_var
if self.use_dropout_A2:
self.layers['DropoutA2'] = Dropout(self.dropout_ratio_A2)
self.layers['ReLU3'] = ReLU() #-----追加------
#----第５層出力----
self.layers['Affine3'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
