def __init__(self,
input_size,
hidden_size,
output_size,
weight_decay_lambda=0.0):
# init para
weight_init_std = 0.01
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(
input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(
hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
# create layers
self.layers = OrderedDict()
self.layers['Affine1'] = layers.Affine(self.params['W1'],
self.params['b1'])
self.layers['Relu1'] = layers.Relu()
self.layers['Affine2'] = layers.Affine(self.params['W2'],
self.params['b2'])
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=2)
# self.loss_list = []
self.weight_decay_lambda = weight_decay_lambda
def __init__(self,
input_size,
hidden_size_list,
output_size,
activation='relu',
weight_init_std='relu',
weight_decay_lambda=0):
self.input_size = input_size
self.output_size = output_size
self.hidden_size_list = hidden_size_list
self.hidden_layer_num = len(hidden_size_list)
self.weight_decay_lambda = weight_decay_lambda
self.params = {}
# 重みの初期化
self.__init_weight(weight_init_std)
# レイヤの生成
activation_layer = {'sigmoid': layers.Sigmoid, 'relu': layers.Relu}
self.layers = OrderedDict()
for idx in range(1, self.hidden_layer_num + 1):
self.layers['Affine' + str(idx)] = layers.Affine(
self.params['W' + str(idx)], self.params['b' + str(idx)])
self.layers['Activation_function' +
str(idx)] = activation_layer[activation]()
idx = self.hidden_layer_num + 1
self.layers['Affine' + str(idx)] = layers.Affine(
self.params['W' + str(idx)], self.params['b' + str(idx)])
self.last_layer = layers.SoftmaxCrossEntropy(class_num=10)
def __init__(self, input_size, hidden_size, output_size):
# init para
weight_init_std = 0.01
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(
input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['gamma1'] = np.ones(hidden_size)
self.params['beta1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(
hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
# create layers
self.layers = OrderedDict()
self.layers['Affine1'] = layers.Affine(self.params['W1'],
self.params['b1'])
self.layers['BatchNorm1'] = layers.BatchNormalization(
self.params['gamma1'], self.params['beta1'])
self.layers['Relu1'] = layers.Relu()
self.layers['Affine2'] = layers.Affine(self.params['W2'],
self.params['b2'])
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=10)
self.loss_list = []
def __init__(self,
input_dim=(1, 28, 28),
conv_param=None,
pool_param=None,
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']
pool_size = pool_param['pool_size']
pool_stride = pool_param['pool_stride']
channel, input_size, _ = input_dim
conv_output_size = (input_size - filter_size +
2 * filter_pad) / filter_stride + 1
pool_output_size = int(filter_num * (conv_output_size / pool_size) *
(conv_output_size / pool_size))
# init para
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(
filter_num, channel, filter_size, filter_size) # 30,1,5,5
self.params['b1'] = np.zeros(filter_num) # 30,
self.params['W2'] = weight_init_std * np.random.randn(
pool_output_size, hidden_size) # (30*12*12),100 => 4320,100
self.params['b2'] = np.zeros(hidden_size) # 100,
self.params['W3'] = weight_init_std * np.random.randn(
hidden_size, output_size) # 100,10
self.params['b3'] = np.zeros(output_size) # 10,
# create layers
self.layers = OrderedDict()
self.layers['Conv1'] = layers.Convolution(self.params['W1'],
self.params['b1'],
filter_stride, filter_pad)
self.layers['Relu1'] = layers.Relu()
self.layers['Pool1'] = layers.Pooling(pool_h=2, pool_w=2, stride=2)
self.layers['Affine1'] = layers.Affine(self.params['W2'],
self.params['b2'])
self.layers['Relu2'] = layers.Relu()
self.layers['Affine2'] = layers.Affine(self.params['W3'],
self.params['b3'])
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=10)
def __init__(self, input_size, hidden_size, output_size):
# init para
weight_init_std = 0.01
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(
input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(
hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
# create layers
self.layers = OrderedDict()
self.layers['Affine1'] = layers.Affine(self.params['W1'],
self.params['b1'])
self.layers['Relu1'] = layers.Relu()
self.layers['Dropout1'] = layers.Dropout(drop_ratio=0.3)
self.layers['Affine2'] = layers.Affine(self.params['W2'],
self.params['b2'])
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=10)
def __init__(self, input_size, hidden_size_list, output_size,
activation='relu', weight_init_std='relu',
weight_decay_lambda=0.0,
use_dropout=False, dropout_ratio=0.5,
use_batchnorm=False):
self.input_size = input_size
self.output_size = output_size
self.hidden_size_list = hidden_size_list
self.hidden_layer_num = len(hidden_size_list)
self.weight_decay_lambda = weight_decay_lambda
self.use_dropout = use_dropout
self.use_batchnorm = use_batchnorm
self.params = {}
# weights initialization
self.__init_weight(weight_init_std)
# generate layers
activation_layer = {'sigmoid': layers.Sigmoid, 'relu': layers.Relu}
self.layers = OrderedDict()
for idx in range(1, self.hidden_layer_num + 1):
self.layers['Affine' + str(idx)] = layers.Affine(self.params['W' + str(idx)],
self.params['b' + str(idx)])
if self.use_batchnorm:
self.layers['BatchNorm' + str(idx)] = layers.BatchNormalization(self.params['gamma' + str(idx)],
self.params['beta' + str(idx)])
self.layers['Activation' + str(idx)] = activation_layer[activation]()
if self.use_dropout:
self.layers['Dropout' + str(idx)] = layers.Dropout(dropout_ratio)
# last Affine layer need no Activation & Batch Norm
idx = self.hidden_layer_num + 1
self.layers['Affine' + str(idx)] = layers.Affine(self.params['W' + str(idx)],
self.params['b' + str(idx)])
self.last_layer = layers.SoftmaxCrossEntropy(class_num=2)
# self.last_layer = layers.MSE()
# dict to save activation layer output
self.activation_dict = OrderedDict()
def __init__(self, input_size, hidden_size, output_size):
# init para
weight_init_std = 0.01
self.params = OrderedDict()
self.params['W1'] = weight_init_std * np.random.randn(
input_size, hidden_size)
# self.params['W1'] = weight_init_std * np.random.normal(loc=0.0, scale=1.0, size=(input_size, hidden_size))
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(
hidden_size, output_size)
# self.params['W2'] = weight_init_std * np.random.normal(loc=0.0, scale=1.0, size=(hidden_size, output_size))
self.params['b2'] = np.zeros(output_size)
# create layers
self.layers = OrderedDict()
self.layers['Affine1'] = layers.Affine(self.params['W1'],
self.params['b1'])
self.layers['Relu1'] = layers.Relu()
self.layers['Affine2'] = layers.Affine(self.params['W2'],
self.params['b2'])
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=10)
self.loss_list = []
def __init__(self,
input_dim=(1, 28, 28),
conv_param_1=None,
conv_param_2=None,
pool_param_1=None,
pool_param_2=None,
hidden_size_1=120,
hidden_size_2=84,
output_size=10,
weight_init_std=0.01):
conv_1_output_h = (input_dim[1] - conv_param_1['filter_size'] + 2 *
conv_param_1['pad']) / conv_param_1['stride'] + 1
pool_1_output_h = int(conv_1_output_h / pool_param_1['pool_h'])
conv_2_output_h = (pool_1_output_h - conv_param_2['filter_size'] + 2 *
conv_param_2['pad']) / conv_param_2['stride'] + 1
pool_2_output_size = int(conv_param_2['filter_num'] *
(conv_2_output_h / pool_param_2['pool_h']) *
(conv_2_output_h / pool_param_2['pool_h']))
# init parameters
self.params = {}
# conv 1
self.params['W1'] = weight_init_std * np.random.randn(
conv_param_1['filter_num'], input_dim[0],
conv_param_1['filter_size'],
conv_param_1['filter_size']) # 6,1,5,5
self.params['b1'] = np.zeros(conv_param_1['filter_num']) # 6,
# conv 2
self.params['W2'] = weight_init_std * np.random.randn(
conv_param_2['filter_num'], conv_param_1['filter_num'],
conv_param_2['filter_size'],
conv_param_2['filter_size']) # 16,1,5,5
self.params['b2'] = np.zeros(conv_param_2['filter_num']) # 16,
# affine 1
self.params['W3'] = weight_init_std * np.random.randn(
pool_2_output_size, hidden_size_1) # (N*4*4),100 => 4320,100
self.params['b3'] = np.zeros(hidden_size_1) # 100,
# affine 2
self.params['W4'] = weight_init_std * np.random.randn(
hidden_size_1, hidden_size_2) # 100,10
self.params['b4'] = np.zeros(hidden_size_2) # 10,
# affine 3 --- out
self.params['W5'] = weight_init_std * np.random.randn(
hidden_size_2, output_size) # 100,10
self.params['b5'] = np.zeros(output_size) # 10,
# create layers
self.layers = OrderedDict()
# conv 1
self.layers['Conv1'] = layers.Convolution(self.params['W1'],
self.params['b1'],
conv_param_1['stride'],
conv_param_1['pad'])
# relu 1
self.layers['Relu1'] = layers.Relu()
# pool 1
self.layers['Pool1'] = layers.Pooling(
pool_h=pool_param_1['pool_h'],
pool_w=pool_param_1['pool_h'],
stride=pool_param_1['pool_stride'])
# conv 2
self.layers['Conv2'] = layers.Convolution(self.params['W2'],
self.params['b2'],
conv_param_1['stride'],
conv_param_1['pad'])
# relu 2
self.layers['Relu2'] = layers.Relu()
# pool 2
self.layers['Pool2'] = layers.Pooling(
pool_h=pool_param_1['pool_h'],
pool_w=pool_param_1['pool_h'],
stride=pool_param_1['pool_stride'])
# affine 1
self.layers['Affine1'] = layers.Affine(self.params['W3'],
self.params['b3'])
# relu 3
self.layers['Relu2'] = layers.Relu()
# affine 2
self.layers['Affine2'] = layers.Affine(self.params['W4'],
self.params['b4'])
# relu 4
self.layers['Relu2'] = layers.Relu()
# affine 3
self.layers['Affine3'] = layers.Affine(self.params['W5'],
self.params['b5'])
# loss
self.lossLayer = layers.SoftmaxCrossEntropy(class_num=10)
self.loss_list = []
