Python keras.layers.convolutional.Conv3D() Examples
The following are 21
code examples of keras.layers.convolutional.Conv3D().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
keras.layers.convolutional
, or try the search function
.
.
Example #1
| Source File: discriminator.py From Generative-Adversarial-Networks-Cookbook with MIT License | 6 votes |
|
def model(self):
input_layer = Input(shape=self.INPUT_SHAPE)
x = self.block(input_layer,filter_size=8)
x = self.block(x,filter_size=16,)
x = self.block(x,filter_size=32)
x = self.block(x,filter_size=64)
x = Conv3D(filters=1, kernel_size=(3,3,3),
strides=(1,1,1), kernel_initializer='glorot_normal',
bias_initializer='zeros', padding='valid')(x)
x = BatchNormalization()(x)
x = Flatten()(x)
output_layer = Dense(1, activation='sigmoid')(x)
model = Model(inputs=input_layer, outputs=output_layer)
return model
Example #2
| Source File: MSnetworks.py From CNNArt with Apache License 2.0 | 6 votes |
|
def InceptionBlock(inp, l1_reg=0.0, l2_reg=1e-6):
KN = fgetKernelNumber()
branch1 = Conv3D(filters=KN[0], kernel_size=(1,1,1), kernel_initializer='he_normal', weights=None,padding='same',
strides=(1,1,1),kernel_regularizer=l1_l2(l1_reg, l2_reg),activation='relu')(inp)
branch3 = Conv3D(filters=KN[0], kernel_size=(1, 1, 1), kernel_initializer='he_normal', weights=None, padding='same',
strides=(1, 1, 1), kernel_regularizer=l1_l2(l1_reg, l2_reg), activation='relu')(inp)
branch3 = Conv3D(filters=KN[2], kernel_size=(3, 3, 3), kernel_initializer='he_normal', weights=None, padding='same',
strides=(1, 1, 1), kernel_regularizer=l1_l2(l1_reg, l2_reg), activation='relu')(branch3)
branch5 = Conv3D(filters=KN[0], kernel_size=(1, 1, 1), kernel_initializer='he_normal', weights=None, padding='same',
strides=(1, 1, 1), kernel_regularizer=l1_l2(l1_reg, l2_reg), activation='relu')(inp)
branch5 = Conv3D(filters=KN[1], kernel_size=(5, 5, 5), kernel_initializer='he_normal', weights=None, padding='same',
strides=(1, 1, 1), kernel_regularizer=l1_l2(l1_reg, l2_reg), activation='relu')(branch5)
branchpool = MaxPooling3D(pool_size=(3,3,3),strides=(1,1,1),padding='same',data_format='channels_first')(inp)
branchpool = Conv3D(filters=KN[0], kernel_size=(1, 1, 1), kernel_initializer='he_normal', weights=None, padding='same',
strides=(1, 1, 1), kernel_regularizer=l1_l2(l1_reg, l2_reg), activation='relu')(branchpool)
out = concatenate([branch1, branch3, branch5, branchpool], axis=1)
return out
Example #3
| Source File: trainer.py From CT-GAN with MIT License | 6 votes |
|
def build_discriminator(self):
def d_layer(layer_input, filters, f_size=4, bn=True):
"""Discriminator layer"""
d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)
d = LeakyReLU(alpha=0.2)(d)
if bn:
d = BatchNormalization(momentum=0.8)(d)
return d
img_A = Input(shape=self.img_shape)
img_B = Input(shape=self.img_shape)
# Concatenate image and conditioning image by channels to produce input
model_input = Concatenate(axis=-1)([img_A, img_B])
d1 = d_layer(model_input, self.df, bn=False)
d2 = d_layer(d1, self.df * 2)
d3 = d_layer(d2, self.df * 4)
d4 = d_layer(d3, self.df * 8)
validity = Conv3D(1, kernel_size=4, strides=1, padding='same')(d4)
return Model([img_A, img_B], validity)
Example #4
| Source File: motion_VNetArt.py From CNNArt with Apache License 2.0 | 6 votes |
|
def fCreateVNet_Block( input_t, channels, type=1, kernel_size=(3,3,3),l1_reg=0.0, l2_reg=1e-6, iPReLU=0, dr_rate=0):
tower_t= Dropout(dr_rate)(input_t)
tower_t = Conv3D(channels,
kernel_size=kernel_size,
kernel_initializer='he_normal',
weights=None,
padding='same',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(tower_t)
tower_t = fGetActivation(tower_t, iPReLU=iPReLU)
for counter in range(1, type):
tower_t = Dropout(dr_rate)(tower_t)
tower_t = Conv3D(channels,
kernel_size=kernel_size,
kernel_initializer='he_normal',
weights=None,
padding='same',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(tower_t)
tower_t = fGetActivation(tower_t, iPReLU=iPReLU)
tower_t = concatenate([tower_t, input_t], axis=1)
return tower_t
Example #5
| Source File: VNetArt.py From CNNArt with Apache License 2.0 | 6 votes |
|
def fCreateVNet_Block(input_t, channels, type=1, kernel_size=(3, 3, 3), l1_reg=0.0, l2_reg=1e-6, iPReLU=0, dr_rate=0):
tower_t = Dropout(dr_rate)(input_t)
tower_t = Conv3D(channels,
kernel_size=kernel_size,
kernel_initializer='he_normal',
weights=None,
padding='same',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(tower_t)
tower_t = fGetActivation(tower_t, iPReLU=iPReLU)
for counter in range(1, type):
tower_t = Dropout(dr_rate)(tower_t)
tower_t = Conv3D(channels,
kernel_size=kernel_size,
kernel_initializer='he_normal',
weights=None,
padding='same',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(tower_t)
tower_t = fGetActivation(tower_t, iPReLU=iPReLU)
tower_t = concatenate([tower_t, input_t], axis=1)
return tower_t
Example #6
| Source File: run.py From Generative-Adversarial-Networks-Projects with MIT License | 5 votes |
|
def build_discriminator():
"""
Create a Discriminator Model using hyperparameters values defined as follows
"""
dis_input_shape = (64, 64, 64, 1)
dis_filters = [64, 128, 256, 512, 1]
dis_kernel_sizes = [4, 4, 4, 4, 4]
dis_strides = [2, 2, 2, 2, 1]
dis_paddings = ['same', 'same', 'same', 'same', 'valid']
dis_alphas = [0.2, 0.2, 0.2, 0.2, 0.2]
dis_activations = ['leaky_relu', 'leaky_relu', 'leaky_relu',
'leaky_relu', 'sigmoid']
dis_convolutional_blocks = 5
dis_input_layer = Input(shape=dis_input_shape)
# The first 3D Convolutional block
a = Conv3D(filters=dis_filters[0],
kernel_size=dis_kernel_sizes[0],
strides=dis_strides[0],
padding=dis_paddings[0])(dis_input_layer)
# a = BatchNormalization()(a, training=True)
a = LeakyReLU(dis_alphas[0])(a)
# Next 4 3D Convolutional Blocks
for i in range(dis_convolutional_blocks - 1):
a = Conv3D(filters=dis_filters[i + 1],
kernel_size=dis_kernel_sizes[i + 1],
strides=dis_strides[i + 1],
padding=dis_paddings[i + 1])(a)
a = BatchNormalization()(a, training=True)
if dis_activations[i + 1] == 'leaky_relu':
a = LeakyReLU(dis_alphas[i + 1])(a)
elif dis_activations[i + 1] == 'sigmoid':
a = Activation(activation='sigmoid')(a)
dis_model = Model(inputs=[dis_input_layer], outputs=[a])
return dis_model
Example #7
| Source File: discriminator.py From Generative-Adversarial-Networks-Cookbook with MIT License | 5 votes |
|
def block(self,first_layer,filter_size=512,kernel_size=(3,3,3)):
x = Conv3D(filters=filter_size, kernel_size=kernel_size, kernel_initializer='glorot_normal',
bias_initializer='zeros', padding='same')(first_layer)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
return x
Example #8
| Source File: model.py From LipNet with MIT License | 5 votes |
|
def build(self):
if K.image_data_format() == 'channels_first':
input_shape = (self.img_c, self.frames_n, self.img_w, self.img_h)
else:
input_shape = (self.frames_n, self.img_w, self.img_h, self.img_c)
self.input_data = Input(name='the_input', shape=input_shape, dtype='float32')
self.zero1 = ZeroPadding3D(padding=(1, 2, 2), name='zero1')(self.input_data)
self.conv1 = Conv3D(32, (3, 5, 5), strides=(1, 2, 2), activation='relu', kernel_initializer='he_normal', name='conv1')(self.zero1)
self.maxp1 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max1')(self.conv1)
self.drop1 = Dropout(0.5)(self.maxp1)
self.zero2 = ZeroPadding3D(padding=(1, 2, 2), name='zero2')(self.drop1)
self.conv2 = Conv3D(64, (3, 5, 5), strides=(1, 1, 1), activation='relu', kernel_initializer='he_normal', name='conv2')(self.zero2)
self.maxp2 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max2')(self.conv2)
self.drop2 = Dropout(0.5)(self.maxp2)
self.zero3 = ZeroPadding3D(padding=(1, 1, 1), name='zero3')(self.drop2)
self.conv3 = Conv3D(96, (3, 3, 3), strides=(1, 1, 1), activation='relu', kernel_initializer='he_normal', name='conv3')(self.zero3)
self.maxp3 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max3')(self.conv3)
self.drop3 = Dropout(0.5)(self.maxp3)
self.resh1 = TimeDistributed(Flatten())(self.drop3)
self.gru_1 = Bidirectional(GRU(256, return_sequences=True, kernel_initializer='Orthogonal', name='gru1'), merge_mode='concat')(self.resh1)
self.gru_2 = Bidirectional(GRU(256, return_sequences=True, kernel_initializer='Orthogonal', name='gru2'), merge_mode='concat')(self.gru_1)
# transforms RNN output to character activations:
self.dense1 = Dense(self.output_size, kernel_initializer='he_normal', name='dense1')(self.gru_2)
self.y_pred = Activation('softmax', name='softmax')(self.dense1)
self.labels = Input(name='the_labels', shape=[self.absolute_max_string_len], dtype='float32')
self.input_length = Input(name='input_length', shape=[1], dtype='int64')
self.label_length = Input(name='label_length', shape=[1], dtype='int64')
self.loss_out = CTC('ctc', [self.y_pred, self.labels, self.input_length, self.label_length])
self.model = Model(inputs=[self.input_data, self.labels, self.input_length, self.label_length], outputs=self.loss_out)
Example #9
| Source File: MSnetworks.py From CNNArt with Apache License 2.0 | 5 votes |
|
def fCreateModel_FCN_simple(patchSize,dr_rate=0.0, iPReLU=0, l1_reg=0.0, l2_reg=1e-6):
# Total params: 1,223,831
# Replace the dense layer with a convolutional layer with filters=2 for the two classes
Strides = fgetStrides()
kernelnumber = fgetKernelNumber()
inp = Input(shape=(1, int(patchSize[0]), int(patchSize[1]), int(patchSize[2])))
after_Conv_1 = fCreateVNet_Block(inp, kernelnumber[0], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_1 = fCreateVNet_DownConv_Block(after_Conv_1, after_Conv_1._keras_shape[1], Strides[0],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
after_Conv_2 = fCreateVNet_Block(after_DownConv_1, kernelnumber[1], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_2 = fCreateVNet_DownConv_Block(after_Conv_2, after_Conv_2._keras_shape[1], Strides[1],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
after_Conv_3 = fCreateVNet_Block(after_DownConv_2, kernelnumber[2], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_3 = fCreateVNet_DownConv_Block(after_Conv_3, after_Conv_3._keras_shape[1], Strides[2],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
dropout_out = Dropout(dr_rate)(after_DownConv_3)
fclayer = Conv3D(2,
kernel_size=(1,1,1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(dropout_out)
fclayer = GlobalAveragePooling3D()(fclayer)
outp = Activation('softmax')(fclayer)
cnn_spp = Model(inputs=inp, outputs=outp)
return cnn_spp
Example #10
| Source File: motion_VNetArt.py From CNNArt with Apache License 2.0 | 5 votes |
|
def fCreateVNet_DownConv_Block(input_t,channels, stride, l1_reg=0.0, l2_reg=1e-6, iPReLU=0, dr_rate=0):
output_t=Dropout(dr_rate)(input_t)
output_t=Conv3D(channels,
kernel_size=stride,
strides=stride,
weights=None,
padding='valid',
kernel_regularizer=l1_l2(l1_reg, l2_reg),
kernel_initializer='he_normal'
)(output_t)
output_t=fGetActivation(output_t,iPReLU=iPReLU)
return output_t
Example #11
| Source File: VNetArt.py From CNNArt with Apache License 2.0 | 5 votes |
|
def fCreateVNet_DownConv_Block(input_t, channels, stride, l1_reg=0.0, l2_reg=1e-6, iPReLU=0, dr_rate=0):
output_t = Dropout(dr_rate)(input_t)
output_t = Conv3D(channels,
kernel_size=stride,
strides=stride,
weights=None,
padding='valid',
kernel_regularizer=l1_l2(l1_reg, l2_reg),
kernel_initializer='he_normal'
)(output_t)
output_t = fGetActivation(output_t, iPReLU=iPReLU)
return output_t
Example #12
| Source File: VNetArt.py From CNNArt with Apache License 2.0 | 5 votes |
|
def fCreateVNet_DownConv_Block(input_t, channels, stride, l1_reg=0.0, l2_reg=1e-6, iPReLU=0, dr_rate=0):
output_t = Dropout(dr_rate)(input_t)
output_t = Conv3D(channels,
kernel_size=stride,
strides=stride,
weights=None,
padding='valid',
kernel_regularizer=l1_l2(l1_reg, l2_reg),
kernel_initializer='he_normal'
)(output_t)
output_t = fGetActivation(output_t, iPReLU=iPReLU)
return output_t
Example #13
| Source File: test.py From MRI-tumor-segmentation-Brats with MIT License | 5 votes |
|
def dense_model(patch_size, num_classes):
merged_inputs = Input(shape=patch_size + (4,), name='merged_inputs')
flair = Reshape(patch_size + (1,))(
Lambda(
lambda l: l[:, :, :, :, 0],
output_shape=patch_size + (1,))(merged_inputs),
)
t2 = Reshape(patch_size + (1,))(
Lambda(lambda l: l[:, :, :, :, 1], output_shape=patch_size + (1,))(merged_inputs)
)
t1 = Lambda(lambda l: l[:, :, :, :, 2:], output_shape=patch_size + (2,))(merged_inputs)
flair = dense_net(flair)
t2 = dense_net(t2)
t1 = dense_net(t1)
t2 = concatenate([flair, t2])
t1 = concatenate([t2, t1])
tumor = Conv3D(2, kernel_size=1, strides=1, name='tumor')(flair)
core = Conv3D(3, kernel_size=1, strides=1, name='core')(t2)
enhancing = Conv3D(num_classes, kernel_size=1, strides=1, name='enhancing')(t1)
net = Model(inputs=merged_inputs, outputs=[tumor, core, enhancing])
return net
Example #14
| Source File: test.py From MRI-tumor-segmentation-Brats with MIT License | 5 votes |
|
def dense_net(input):
x = Conv3D(filters=24, kernel_size=3, strides=1, kernel_initializer='he_uniform', padding='same', use_bias=False)(
input)
x = DenseNetUnit3D(x, growth_rate=12, ksize=3, n=4)
x = DenseNetTransit(x)
x = DenseNetUnit3D(x, growth_rate=12, ksize=3, n=4)
x = DenseNetTransit(x)
x = DenseNetUnit3D(x, growth_rate=12, ksize=3, n=4)
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
Example #15
| Source File: test.py From MRI-tumor-segmentation-Brats with MIT License | 5 votes |
|
def DenseNetTransit(x, rate=1, name=None):
if rate != 1:
out_features = x.get_shape().as_list()[-1] * rate
x = BatchNormalization(center=True, scale=True, name=name + '_bn')(x)
x = Activation('relu', name=name + '_relu')(x)
x = Conv3D(filters=out_features, kernel_size=1, strides=1, padding='same', kernel_initializer='he_normal',
use_bias=False, name=name + '_conv')(x)
x = AveragePooling3D(pool_size=2, strides=2, padding='same')(x)
return x
Example #16
| Source File: test.py From MRI-tumor-segmentation-Brats with MIT License | 5 votes |
|
def DenseNetUnit3D(x, growth_rate, ksize, n, bn_decay=0.99):
for i in range(n):
concat = x
x = BatchNormalization(center=True, scale=True, momentum=bn_decay)(x)
x = Activation('relu')(x)
x = Conv3D(filters=growth_rate, kernel_size=ksize, padding='same', kernel_initializer='he_uniform',
use_bias=False)(x)
x = concatenate([concat, x])
return x
Example #17
| Source File: 3D_CNN.py From CNNArt with Apache License 2.0 | 4 votes |
|
def fCreateModel(patchSize, learningRate=1e-3, optimizer='SGD',
dr_rate=0.0, input_dr_rate=0.0, max_norm=5, iPReLU=0, l2_reg=1e-6):
# change to functional API
input_t = Input(shape=(1, int(patchSize[0, 0]), int(patchSize[0, 1]), int(patchSize[0, 2])))
seq_t = Dropout(dr_rate)(input_t)
seq_t = Conv3D(32, # numChans
kernel_size=(14, 14, 5),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg),
input_shape=(1, int(patchSize[0, 0]), int(patchSize[0, 1]), int(patchSize[0, 2]))
)(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(64,
kernel_size=(7, 7, 3),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(128,
kernel_size=(3, 3, 2),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Flatten()(seq_t)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Dense(units=2,
kernel_initializer='normal',
kernel_regularizer=l2(l2_reg))(seq_t)
output_t = Activation('softmax')(seq_t)
opti, loss = fGetOptimizerAndLoss(optimizer, learningRate=learningRate) # loss cat_crosent default
cnn = Model(inputs=[input_t], outputs=[output_t])
cnn.compile(loss=loss, optimizer=opti, metrics=['accuracy'])
sArchiSpecs = '_l2{}'.format(l2_reg)
####################################################################helpers#############################################
Example #18
| Source File: motion_CNN3D.py From CNNArt with Apache License 2.0 | 4 votes |
|
def fCreateModel(patchSize, learningRate=1e-3, optimizer='SGD',
dr_rate=0.0, input_dr_rate=0.0, max_norm=5, iPReLU=0, l2_reg=1e-6):
# change to functional API
input_t = Input(shape=(1, int(patchSize[0]), int(patchSize[1]), int(patchSize[2])))
seq_t= Dropout(dr_rate)(input_t)
seq_t = Conv3D(32, # numChans
kernel_size=(14, 14, 5),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg),
input_shape=(1, int(patchSize[0]), int(patchSize[1]), int(patchSize[2]))
)(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(64,
kernel_size=(7, 7, 3),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(128,
kernel_size=(3, 3, 2),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Flatten()(seq_t)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Dense(units=2,
kernel_initializer='normal',
kernel_regularizer=l2(l2_reg))(seq_t)
output_t = Activation('softmax')(seq_t)
opti, loss = fGetOptimizerAndLoss(optimizer, learningRate=learningRate) # loss cat_crosent default
cnn = Model(inputs=[input_t], outputs=[output_t])
cnn.compile(loss=loss, optimizer=opti, metrics=['accuracy'])
sArchiSpecs = '_l2{}'.format(l2_reg)
return cnn
####################################################################helpers#############################################
Example #19
| Source File: CNN3D.py From CNNArt with Apache License 2.0 | 4 votes |
|
def fCreateModel(patchSize, learningRate=1e-3, optimizer='SGD',
dr_rate=0.0, input_dr_rate=0.0, max_norm=5, iPReLU=0, l2_reg=1e-6):
# change to functional API
input_t = Input(shape=(1, int(patchSize[0, 0]), int(patchSize[0, 1]), int(patchSize[0, 2])))
seq_t = Dropout(dr_rate)(input_t)
seq_t = Conv3D(32, # numChans
kernel_size=(14, 14, 5),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg),
input_shape=(1, int(patchSize[0, 0]), int(patchSize[0, 1]), int(patchSize[0, 2]))
)(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(64,
kernel_size=(7, 7, 3),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Conv3D(128,
kernel_size=(3, 3, 2),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l2(l2_reg))(seq_t)
seq_t = fGetActivation(seq_t, iPReLU=iPReLU)
seq_t = Flatten()(seq_t)
seq_t = Dropout(dr_rate)(seq_t)
seq_t = Dense(units=2,
kernel_initializer='normal',
kernel_regularizer=l2(l2_reg))(seq_t)
output_t = Activation('softmax')(seq_t)
opti, loss = fGetOptimizerAndLoss(optimizer, learningRate=learningRate) # loss cat_crosent default
cnn = Model(inputs=[input_t], outputs=[output_t])
cnn.compile(loss=loss, optimizer=opti, metrics=['accuracy'])
sArchiSpecs = '_l2{}'.format(l2_reg)
####################################################################helpers#############################################
Example #20
| Source File: MSnetworks.py From CNNArt with Apache License 2.0 | 4 votes |
|
def fCreateModel_FCN_MultiFM(patchSize, dr_rate=0.0, iPReLU=0,l1_reg=0, l2_reg=1e-6):
# Total params: 1,420,549
# The dense layer is repleced by a convolutional layer with filters=2 for the two classes
# The FM from the third down scaled convolutional layer is upsempled by deconvolution and
# added with the FM from the second down scaled convolutional layer.
# The combined FM goes through a convolutional layer with filters=2 for the two classes
# The two predictions are averages as the final result.
Strides = fgetStrides()
kernelnumber = fgetKernelNumber()
inp = Input(shape=(1, int(patchSize[0]), int(patchSize[1]), int(patchSize[2])))
after_Conv_1 = fCreateVNet_Block(inp, kernelnumber[0], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_1 = fCreateVNet_DownConv_Block(after_Conv_1, after_Conv_1._keras_shape[1], Strides[0],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
after_Conv_2 = fCreateVNet_Block(after_DownConv_1, kernelnumber[1], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_2 = fCreateVNet_DownConv_Block(after_Conv_2, after_Conv_2._keras_shape[1], Strides[1],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
after_Conv_3 = fCreateVNet_Block(after_DownConv_2, kernelnumber[2], type=fgetLayerNumConv(), l2_reg=l2_reg)
after_DownConv_3 = fCreateVNet_DownConv_Block(after_Conv_3, after_Conv_3._keras_shape[1], Strides[2],
iPReLU=iPReLU, dr_rate=dr_rate, l2_reg=l2_reg)
# fully convolution over the FM from the deepest level
dropout_out1 = Dropout(dr_rate)(after_DownConv_3)
fclayer1 = Conv3D(2,
kernel_size=(1,1,1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(dropout_out1)
fclayer1 = GlobalAveragePooling3D()(fclayer1)
# Upsample FM from the deepest level, add with FM from level 2,
UpedFM_Level3 = Conv3DTranspose(filters=97, kernel_size=(3,3,1), strides=(2,2,1), padding='same')(after_DownConv_3)
conbined_FM_Level23 = add([UpedFM_Level3, after_DownConv_2])
fclayer2 = Conv3D(2,
kernel_size=(1,1,1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(conbined_FM_Level23)
fclayer2 = GlobalAveragePooling3D()(fclayer2)
# combine the two predictions using average
fcl_aver = average([fclayer1, fclayer2])
predict = Activation('softmax')(fcl_aver)
cnn_fcl_msfm = Model(inputs=inp, outputs=predict)
return cnn_fcl_msfm
Example #21
| Source File: model2.py From LipNet with MIT License | 4 votes |
|
def build(self):
if K.image_data_format() == 'channels_first':
input_shape = (self.img_c, self.frames_n, self.img_w, self.img_h)
else:
input_shape = (self.frames_n, self.img_w, self.img_h, self.img_c)
self.input_data = Input(name='the_input', shape=input_shape, dtype='float32')
self.zero1 = ZeroPadding3D(padding=(1, 2, 2), name='zero1')(self.input_data)
self.conv1 = Conv3D(32, (3, 5, 5), strides=(1, 2, 2), kernel_initializer='he_normal', name='conv1')(self.zero1)
self.batc1 = BatchNormalization(name='batc1')(self.conv1)
self.actv1 = Activation('relu', name='actv1')(self.batc1)
self.drop1 = SpatialDropout3D(0.5)(self.actv1)
self.maxp1 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max1')(self.drop1)
self.zero2 = ZeroPadding3D(padding=(1, 2, 2), name='zero2')(self.maxp1)
self.conv2 = Conv3D(64, (3, 5, 5), strides=(1, 1, 1), kernel_initializer='he_normal', name='conv2')(self.zero2)
self.batc2 = BatchNormalization(name='batc2')(self.conv2)
self.actv2 = Activation('relu', name='actv2')(self.batc2)
self.drop2 = SpatialDropout3D(0.5)(self.actv2)
self.maxp2 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max2')(self.drop2)
self.zero3 = ZeroPadding3D(padding=(1, 1, 1), name='zero3')(self.maxp2)
self.conv3 = Conv3D(96, (3, 3, 3), strides=(1, 1, 1), kernel_initializer='he_normal', name='conv3')(self.zero3)
self.batc3 = BatchNormalization(name='batc3')(self.conv3)
self.actv3 = Activation('relu', name='actv3')(self.batc3)
self.drop3 = SpatialDropout3D(0.5)(self.actv3)
self.maxp3 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='max3')(self.drop3)
self.resh1 = TimeDistributed(Flatten())(self.maxp3)
self.gru_1 = Bidirectional(GRU(256, return_sequences=True, kernel_initializer='Orthogonal', name='gru1'), merge_mode='concat')(self.resh1)
self.gru_2 = Bidirectional(GRU(256, return_sequences=True, kernel_initializer='Orthogonal', name='gru2'), merge_mode='concat')(self.gru_1)
# transforms RNN output to character activations:
self.dense1 = Dense(self.output_size, kernel_initializer='he_normal', name='dense1')(self.gru_2)
self.y_pred = Activation('softmax', name='softmax')(self.dense1)
self.labels = Input(name='the_labels', shape=[self.absolute_max_string_len], dtype='float32')
self.input_length = Input(name='input_length', shape=[1], dtype='int64')
self.label_length = Input(name='label_length', shape=[1], dtype='int64')
self.loss_out = CTC('ctc', [self.y_pred, self.labels, self.input_length, self.label_length])
self.model = Model(inputs=[self.input_data, self.labels, self.input_length, self.label_length], outputs=self.loss_out)
