def build_discriminator(self): model = Sequential() model.add( Conv2D(32, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=3, strides=2, padding="same")) model.add(ZeroPadding2D(padding=((0, 1), (0, 1)))) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=3, strides=2, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(256, kernel_size=3, strides=1, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # model.summary() img = Input(shape=self.img_shape) validity = model(img) return Model(img, validity)
def __init__(self): self.growth_rate = 32 in_ = Input(shape=(224, 224, 3)) self.num_dense_block = 4 # Layer 1: x = Conv2D(64, (7, 7), (2, 2), padding="SAME")(in_) x = BatchNormalization()(x) x = Activation("relu")(x) x = MaxPool2D((3, 3), (2, 2), padding="VALID")(x) filter = 64 num_node_each_layer = [6, 12, 24, 16] for i in range(self.num_dense_block): x, filter = dense_block(x, num_node_each_layer[i], filter, growth_rate=32) if i != self.num_dense_block - 1: x = transition_block(x, filter, 1.0) filter = filter * 1.0 # Output from loop statement, x still in conv layer x = BatchNormalization()(x) x = Activation("relu")(x) x = GlobalAveragePooling2D()(x) x = Dense(1000, activation="softmax")(x) model = Model(inputs=in_, outputs=x) model.summary() self.model = model
def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000): self.features = [ Conv2D(num_init_features, kernel_size=(7,7), strides=(2,2), padding='same', use_bias=False), #('conv0', Conv2D(num_init_features, kernel_size=(7,7), strides=(2,2), padding='same', use_bias=False)), BatchNormalization(), #('norm0', BatchNormalization()), Activation('relu'), #('relu0', Activation('relu')), MaxPooling2D(pool_size=(3,3), strides=(2,2), padding='same') #('pool0', MaxPooling2D(pool_size=(3,3), strides=(2,2), padding='same')) ] self.num_init_features = num_init_features self.block_config = block_config self.bn_size = bn_size self.growth_rate = growth_rate self.drop_rate = drop_rate # Each denseblock # num_features = num_init_features # for i, num_layers in enumerate(block_config): # block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate) # self.features.add_module('denseblock%d' % (i + 1), block) # num_features = num_features + num_layers * growth_rate # if i != len(block_config) - 1: # trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2) # self.features.add_module('transition%d' % (i + 1), trans) # num_features = num_features // 2 # Final batch norm self.BN_last = BatchNormalization() #self.features.add_module('norm5', BatchNormalization()) # Linear layer self.classifier = Dense(num_classes) #self.classifier = nn.Linear(num_features, num_classes)
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate): self.BN1 = BatchNormalization() #self.add_module('norm.1', BatchNormalization()), self.relu = Activation('relu') #self.add_module('relu.1', Activation('relu')), self.conv = Conv2D(bn_size *growth_rate, kernel_size=(1,1), strides=(1,1), use_bias=False) #self.add_module('conv.1', Conv2D(bn_size *growth_rate, kernel_size=(1,1), strides=(1,1), use_bias=False)), self.BN2 = BatchNormalization() #self.add_module('norm.2', BatchNormalization()), self.relu2 = Activation('relu') #self.add_module('relu.2', Activation('relu')), self.conv2 = Conv2D(growth_rate,kernel_size=(3,3), strides=(1,1), padding='same', use_bias=False) #self.add_module('conv.2', Conv2D(growth_rate,kernel_size=(3,3), strides=(1,1), padding='same', use_bias=False)), self.drop_rate = drop_rate
def res(x): x = ResidualStart()(x) x1 = Conv2D(f, 3, strides=1, padding='same')(x) x1 = BatchNormalization()(x1) x1 = Lambda(activation)(x1) x1 = Conv2D(f, 3, strides=1, padding='same')(x1) x1 = BatchNormalization()(x1) return Add()([x1, x])
def apply_bn(data, model): if data.dataset == "cifar" \ or data.dataset == "caltech_siluettes" \ or data.dataset == "cifar100" \ or data.dataset == "tiny-imagenet-200": model.add(BatchNormalization(momentum=0.9)) elif data.dataset == "GTSRB" \ or data.dataset == "caltech_siluettes": model.add(BatchNormalization(momentum=0.8)) else: model.add(BatchNormalization())
def conv_block(input_, filter): in_filter = filter * 4 x = BatchNormalization()(input_) x = Activation("relu")(x) x = Conv2D(in_filter, (1, 1), strides=(1, 1), padding="SAME")(x) x = BatchNormalization()(x) x = Activation("relu")(x) # x = ZeroPadding2D((1, 1))(x) x = Conv2D(filter, (3, 3), strides=(1, 1), padding="SAME")(x) return x
def init_model(self): with tf.variable_scope('xnor'): x = self.input_img x = tf.pad(x, [[0, 0], [2, 2], [2, 2], [0, 0]]) x = Conv2D(192, 5, padding='valid', name='conv1', kernel_initializer=tf.random_normal_initializer( mean=0.0, stddev=0.05))(x) x = BatchNormalization(axis=3, epsilon=1e-4, momentum=0.9, center=False, scale=False, name='bn1')(x) x = Activation('relu')(x) x = binary_conv(x, 1, 160, 0, 1, 'conv2') x = binary_conv(x, 1, 96, 0, 1, 'conv3') x = tf.pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]]) x = MaxPooling2D((3, 3), strides=2, padding='valid')(x) x = binary_conv(x, 5, 192, 2, 1, 'conv4', dropout=0.5) x = binary_conv(x, 1, 192, 0, 1, 'conv5') x = binary_conv(x, 1, 192, 0, 1, 'conv6') x = tf.pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]]) x = AveragePooling2D((3, 3), strides=2, padding='valid')(x) x = binary_conv(x, 3, 192, 1, 1, 'conv7', dropout=0.5) x = binary_conv(x, 1, 192, 0, 1, 'conv8') x = BatchNormalization(axis=3, epsilon=1e-4, momentum=0.9, center=False, scale=False, name='bn8')(x) x = Conv2D(10, 1, padding='valid', name='conv9', kernel_initializer=tf.random_normal_initializer( mean=0.0, stddev=0.05))(x) x = Activation('relu')(x) x = AveragePooling2D((8, 8), strides=1, padding='valid')(x) x = Flatten()(x) x = Activation('softmax')(x) self.output = x
def __init__(self, inplanes, planes, stride=1, downsample=None): # self.conv1 = conv3x3(planes, stride) # self.bn1 = BatchNorm2d(planes) # self.relu = nn.ReLU(inplace=True) # self.conv2 = conv3x3(planes, planes) # self.bn2 = nn.BatchNorm2d(planes) # self.downsample = downsample # self.stride = stride self.conv1 = conv3x3(planes, stride) self.bn1 = BatchNormalization() self.relu = Activation('relu') self.conv2 = conv3x3(planes) self.bn2 = BatchNormalization() self.downsample = downsample self.stride = stride
def __init__(self, block, layers, num_classes=1000): # self.inplanes = 64 # self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False) # self.bn1 = nn.BatchNorm2d(64) # self.relu = nn.ReLU(inplace=True) # self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) # self.layer1 = self._make_layer(block, 64, layers[0]) # self.layer2 = self._make_layer(block, 128, layers[1], stride=2) # self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # self.layer4 = self._make_layer(block, 512, layers[3], stride=2) # self.avgpool = nn.AvgPool2d(7) # self.fc = nn.Linear(512 * block.expansion, num_classes) self.inplanes = 64 self.conv1 = Conv2D(64,kernel_size=(7,7),strides=(2,2),padding='same',use_bias=False) self.bn1 = BatchNormalization() self.relu = Activation('relu') self.maxpool = MaxPooling2D(pool_size=(3,3),strides=(2,2),padding='same') self.block = block self.layers = layers # self.layer1 = self._make_layer(block, 64, layers[0]) # self.layer2 = self._make_layer(block, 128, layers[1], stride=2) # self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.avgpool = AveragePooling2D(pool_size=(7,7)) self.fc = Dense(num_classes)
def layer1_multistream(input_dim1, input_dim2, input_dim3, filt_num, do_vis=False, name=None): seq = Sequential() ''' Multi-Stream layer : Conv - Relu - Conv - BN - Relu ''' if do_vis: global feats global feat_names # seq.add(Reshape((input_dim1,input_dim12,input_dim3),input_shape=(input_dim1, input_dim2, input_dim3,1))) for i in range(3): seq.add( Conv2D(int(filt_num), (2, 2), input_shape=(input_dim1, input_dim2, input_dim3), padding='valid', name='S1_c1%d' % (i))) seq.add(Activation('relu', name='S1_relu1%d' % (i))) seq.add( Conv2D(int(filt_num), (2, 2), padding='valid', name='S1_c2%d' % (i))) seq.add(BatchNormalization(axis=-1, name='S1_BN%d' % (i))) seq.add(Activation('relu', name='S1_relu2%d' % (i))) if do_vis: feats.append(seq) feat_names.append(name + '_S1_c22') seq.add(Reshape((input_dim1 - 6, input_dim2 - 6, int(filt_num)))) return seq
def _BN_ReLU_Conv2d(x, nb_filter, kernel_size, strides=(1, 1), padding='same', name=None): if name is not None: bn_name = name + '_bn' relu_name = name + '_relu' conv_name = name + '_conv' else: bn_name = None relu_name = None conv_name = None x = BatchNormalization(axis=3, name=bn_name)(x) x = PReLU()(x) x = Conv2D(nb_filter, kernel_size, padding=padding, strides=strides, activation=None, name=conv_name)(x) return x
def add_conv_layer(self, img_size=(32, 32), img_channels=3): self.classifier.add( BatchNormalization(input_shape=(img_size[0], img_size[1], img_channels))) self.classifier.add( Conv2D(32, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(32, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(64, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(64, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(128, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(128, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25)) self.classifier.add( Conv2D(256, (3, 3), padding='same', activation='relu')) self.classifier.add(Conv2D(256, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=2)) self.classifier.add(Dropout(0.25))
def build_local_model(self): input = Input(shape=self.state_size) conv = TimeDistributed( Conv2D(32, (8, 8), strides=(4, 4), activation="elu"))(input) conv = TimeDistributed( Conv2D(32, (4, 4), strides=(2, 2), activation="elu"))(conv) conv = TimeDistributed( Conv2D(32, (3, 3), strides=(1, 1), activation='elu'))(conv) conv = TimeDistributed( Conv2D(8, (1, 1), strides=(1, 1), activation='elu'))(conv) conv = TimeDistributed(Flatten())(conv) conv = BatchNormalization()(conv) lstm = GRU(256, activation='tanh')(conv) policy = Dense(self.action_size, activation="softmax")(lstm) value = Dense(1, activation='linear')(lstm) local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) return local_actor, local_critic
def decoder_block(x, y, scope, size=None, upconv=True, ksize=(3, 3), upsize=(2, 2), upstirdes=(2, 2), act_fn='relu', ep_collection='end_points', reuse=None, batch_norm=True, dropout=0.0): if size is None: base_size = x.get_shape().as_list()[-1] size = int(base_size / 2) with tf.variable_scope(scope, scope, [x], reuse=reuse) as sc: x = ThresholdedReLU(theta=0.0)(x) uped = Conv2DTranspose(size, upsize, strides=upstirdes, padding='same')(x) if upconv else x uped, y = reconcile_feature_size(uped, y) up = concatenate([uped, y], axis=3) tf.add_to_collection(ep_collection, up) conv = Conv2D(size, ksize, activation=act_fn, padding='same')(up) tf.add_to_collection(ep_collection, conv) conv = Conv2D(size, ksize, activation=act_fn, padding='same')(conv) tf.add_to_collection(ep_collection, conv) if batch_norm: conv = BatchNormalization()(conv, training=True) tf.add_to_collection(ep_collection, conv) if dropout > 0.0: conv = Dropout(dropout)(conv) tf.add_to_collection(ep_collection, conv) return conv
def layer1_multistream(input_dim1, input_dim2, input_dim3, filt_num, channelImage): seq = Sequential() ''' Multi-Stream layer : Conv - Relu - Conv - BN - Relu ''' #seq.add(Reshape((input_dim1,input_dim2,input_dim3),input_shape=(input_dim1, input_dim2, input_dim3,1))) for i in range(3): #seq.add(Conv2D(int(filt_num),(2,2),input_shape=(input_dim1, input_dim2, input_dim3), padding='valid', name='S1_c1%d' %(i),data_format='channels_last' )) seq.add( Conv3D(int(filt_num), (2, 2, 2), input_shape=(input_dim1, input_dim2, input_dim3, channelImage), padding='valid', name='S1_c1%d' % (i), data_format='channels_last')) seq.add(Activation('relu', name='S1_relu1%d' % (i))) seq.add( Conv3D(int(filt_num), (2, 2, 2), padding='valid', name='S1_c2%d' % (i), data_format='channels_last')) seq.add(BatchNormalization(axis=-1, name='S1_BN%d' % (i))) seq.add(Activation('relu', name='S1_relu2%d' % (i))) #seq.add(Reshape((input_dim1-6,input_dim2-6,int(filt_num)))) return seq
def vgg(self, type=16, bn=False, img_size=(224, 224), img_channels=3, output_size=1000): if type == 16 and bn == False: layer_list = vgg.vgg16(num_classes=output_size) elif type == 16 and bn == True: layer_list = vgg.vgg16_bn(num_classes=output_size) elif type == 11 and bn == False: layer_list = vgg.vgg11(num_classes=output_size) elif type == 11 and bn == True: layer_list = vgg.vgg11_bn(num_classes=output_size) elif type == 13 and bn == False: layer_list = vgg.vgg13(num_classes=output_size) elif type == 13 and bn == True: layer_list = vgg.vgg13_bn(num_classes=output_size) elif type == 19 and bn == False: layer_list = vgg.vgg19(num_classes=output_size) elif type == 19 and bn == True: layer_list = vgg.vgg19_bn(num_classes=output_size) else: print("请输入11,13,16,19这四个数字中的一个!") self.classifier.add( BatchNormalization(input_shape=(*img_size, img_channels))) for i, value in enumerate(layer_list): self.classifier.add(eval(value))
def convolutional_block(X, f, filters, stage, block, s=2): # defining name basis conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' F1, F2, F3 = filters X_shortcut = X X = Conv2D(F1, (1, 1), strides=(s, s), name=conv_name_base + '2a', padding="valid", kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X) X = Activation('relu')(X) X = Conv2D(F2, (f, f), strides=(1, 1), padding='same', name=conv_name_base + '2b', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X) X = Activation('relu')(X) X = Conv2D(F3, (1, 1), strides=(1, 1), padding='valid', name=conv_name_base + '2c', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X) X_shortcut = Conv2D(F3, (1, 1), strides=(s, s), padding='valid', name=conv_name_base + '1', kernel_initializer=glorot_uniform(seed=0))(X_shortcut) X_shortcut = BatchNormalization(axis=3, name=bn_name_base + '1')(X_shortcut) X = Add()([X, X_shortcut]) X = Activation('relu')(X) return X
def convbn_3d(input, out_planes, kernel_size, stride): seq = Conv3D(out_planes, kernel_size, stride, 'same', data_format='channels_last', use_bias=False)(input) seq = BatchNormalization()(seq) return seq
def get_model(): """ get model """ checkpoint = ModelCheckpoint(MODEL_NAME, monitor='val_acc', verbose=1, save_best_only=True) model = Sequential() input_shape = (IMAGE_SIZE, IMAGE_SIZE, 3) model.add(BatchNormalization(input_shape=input_shape)) model.add(Conv2D(32, (3, 3), padding='same', activation='relu')) model.add(Conv2D(32, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.25)) model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.25)) model.add(Conv2D(128, (3, 3), padding='same', activation='relu')) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.25)) model.add(Conv2D(256, (3, 3), padding='same', activation='relu')) model.add(Conv2D(256, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.5)) model.add(Dense(N_CLASSES, activation='sigmoid')) return model
def __init__(self, inplanes, planes, stride=1, downsample=None): # self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) # self.bn1 = nn.BatchNorm2d(planes) # self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, # padding=1, bias=False) # self.bn2 = nn.BatchNorm2d(planes) # self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) # self.bn3 = nn.BatchNorm2d(planes * 4) # self.relu = nn.ReLU(inplace=True) # self.downsample = downsample # self.stride = stride self.conv1 = Conv2D(planes,kernel_size=(1,1),use_bias=False) self.bn1 = BatchNormalization() self.conv2 = Conv2D(planes,kernel_size=(3,3),strides=(stride,stride),padding='same',use_bias=False) self.bn2 = BatchNormalization() self.conv3 = Conv2D(planes * 4, kernel_size=(1,1), use_bias=False) self.bn3 = BatchNormalization() self.relu = Activation('relu') self.downsample = downsample self.stride = stride
def convbn(input, out_planes, kernel_size, stride, dilation): seq = Conv2D(out_planes, kernel_size, stride, 'same', dilation_rate=dilation, use_bias=False)(input) seq = BatchNormalization()(seq) return seq
def add_conv_layer(self, img_size=(32, 32), img_channels=3): self.classifier.add(BatchNormalization(input_shape=(*img_size, img_channels))) self.classifier.add(Conv2D(32, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25)) self.classifier.add(Conv2D(64, (3, 3), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25)) self.classifier.add(Conv2D(16, (2, 2), activation='relu')) self.classifier.add(MaxPooling2D(pool_size=(2, 2))) self.classifier.add(Dropout(0.25))
def _make_layer(input, planes, blocks, stride, dilation): inplanes = 4 downsample = None if stride != 1 or inplanes != planes: downsample = Conv2D(planes, 1, stride, 'same', use_bias=False)(input) downsample = BatchNormalization()(downsample) layers = BasicBlock(input, planes, stride, downsample, dilation) for i in range(1, blocks): layers = BasicBlock(layers, planes, 1, None, dilation) return layers
def layer2_merged(input_dim1,input_dim2,input_dim3,filt_num,conv_depth): ''' Merged layer : Conv - Relu - Conv - BN - Relu ''' seq = Sequential() for i in range(conv_depth): seq.add(Conv2D(filt_num,(2,2), padding='valid',input_shape=(input_dim1, input_dim2, input_dim3), name='S2_c1%d' % (i) )) seq.add(Activation('relu', name='S2_relu1%d' %(i))) seq.add(Conv2D(filt_num,(2,2), padding='valid', name='S2_c2%d' % (i))) seq.add(BatchNormalization(axis=-1, name='S2_BN%d' % (i))) seq.add(Activation('relu', name='S2_relu2%d' %(i))) return seq
def classifier(self, x): scope = Scoping.get_global_scope() with scope.name_scope('classifier'): if self.data_set == 'NTURGBD': blocks = [{'size': 128, 'bneck': 32, 'groups': 16, 'strides': 1}, {'size': 256, 'bneck': 64, 'groups': 16, 'strides': 2}, {'size': 512, 'bneck': 128, 'groups': 16, 'strides': 2}] n_reps = 3 else: blocks = [{'size': 64, 'bneck': 32, 'groups': 8, 'strides': 3}, {'size': 128, 'bneck': 64, 'groups': 8, 'strides': 3}] n_reps = 3 def _data_augmentation(x): return K.in_train_phase(_sim_occlusions(_jitter_height(x)), x) x = Lambda(_data_augmentation, name=scope+"data_augmentation")(x) x = CombMatrix(self.njoints, name=scope+'comb_matrix')(x) x = EDM(name=scope+'edms')(x) x = Reshape((self.njoints * self.njoints, self.seq_len, 1), name=scope+'resh_in')(x) x = BatchNormalization(axis=-1, name=scope+'bn_in')(x) x = Conv2D(blocks[0]['bneck'], 1, 1, name=scope+'conv_in', **CONV2D_ARGS)(x) for i in range(len(blocks)): for j in range(n_reps): with scope.name_scope('block_%d_%d' % (i, j)): x = _conv_block(x, blocks[i]['size'], blocks[i]['bneck'], blocks[i]['groups'], 3, blocks[i]['strides'] if j == 0 else 1) x = Lambda(lambda args: K.mean(args, axis=(1, 2)), name=scope+'mean_pool')(x) x = BatchNormalization(axis=-1, name=scope + 'bn_out')(x) x = Activation('relu', name=scope + 'relu_out')(x) x = Dropout(self.dropout, name=scope+'dropout')(x) x = Dense(self.num_actions, activation='softmax', name=scope+'label')(x) return x
def __init__(self, img_size, img_channels=3, output_size=17): self.losses = [] self.model = Sequential() self.model.add( BatchNormalization(input_shape=(img_size[0], img_size[1], img_channels))) self.model.add(Conv2D(32, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(32, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(64, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(128, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(128, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(256, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(512, (3, 3), activation='relu')) self.model.add(MaxPooling2D(pool_size=2)) self.model.add(Dropout(0.3)) self.model.add(Flatten()) self.model.add(Dense(512, activation='relu')) self.model.add(BatchNormalization()) self.model.add(Dropout(0.5)) self.model.add(Dense(output_size, activation='sigmoid'))
def identity_block(X, f, filters, stage, block): conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' F1, F2, F3 = filters X_shortcut = X X = Conv2D(filters=F1, kernel_size=(1, 1), strides=(1, 1), padding='valid', name=conv_name_base + '2a', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X) X = Activation('relu')(X) X = Conv2D(filters=F2, kernel_size=(f, f), strides=(1, 1), padding='same', name=conv_name_base + '2b', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X) X = Activation('relu')(X) X = Conv2D(filters=F3, kernel_size=(1, 1), strides=(1, 1), padding='valid', name=conv_name_base + '2c', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X) X = Add()([X, X_shortcut]) X = Activation('relu')(X) return X
def layersP1_multistream(input_shape, filters_count): seq = Sequential() for i in range(3): seq.add(Conv2D(int(filters_count), (2, 2), input_shape=input_shape, padding='same', name='seq1_conv1_%d' % (i))) seq.add(Activation('relu', name='seq1_relu1_%d' % i)) seq.add(Conv2D(int(filters_count), (2, 2), padding='same', name='seq1_conv2_%d' % (i))) seq.add(BatchNormalization(axis=-1, name='seq1_BN_%d' % i)) seq.add(Activation('relu', name='seq1_relu2_%d' % i)) return seq
def build_generator(self): model = Sequential() model.add( Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim)) model.add(Reshape((7, 7, 128))) model.add(UpSampling2D()) model.add(Conv2D(128, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(Activation("relu")) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(Activation("relu")) model.add(Conv2D(self.channels, kernel_size=3, padding="same")) model.add(Activation("tanh")) # model.summary() noise = Input(shape=(self.latent_dim, )) img = model(noise) return Model(noise, img)