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 = []