def build_generator(img_shape, num_classes, latent_dim):
model = Sequential()
model.add(Dense(256, input_dim=latent_dim))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(1024))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(np.prod(img_shape), activation='tanh'))
model.add(Reshape(img_shape))
model.summary()
noise = Input(shape=(latent_dim, ))
label = Input(shape=(1, ), dtype='int32')
label_embedding = Flatten()(Embedding(num_classes, latent_dim)(label))
model_input = multiply([noise, label_embedding])
img = model(model_input)
return Model([noise, label], img)
def build_critic(self):
model = Sequential()
model.add(
Conv2D(16,
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(32, 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(64, 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(128, 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))
model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def build_discriminator(img_shape, num_classes, optimizer):
model = Sequential()
model.add(Dense(512, input_dim=np.prod(img_shape)))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.4))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.4))
model.add(Dense(1, activation='sigmoid'))
model.summary()
img = Input(shape=img_shape)
label = Input(shape=(1, ), dtype='int32')
label_embedding = Flatten()(Embedding(num_classes,
np.prod(img_shape))(label))
flat_img = Flatten()(img)
model_input = multiply([flat_img, label_embedding])
validity = model(model_input)
# Compilar discriminator
Model2 = Model([img, label], validity)
Model2.compile(loss=['binary_crossentropy'],
optimizer=optimizer,
metrics=['accuracy'])
return Model2
def discriminator(image_shape):
dis_input = Input(shape=image_shape)
model = Conv2D(filters=64, kernel_size=3, strides=1,
padding="same")(dis_input)
model = LeakyReLU(alpha=0.2)(model)
model = discriminator_block(model, 64, 3, 2)
model = discriminator_block(model, 128, 3, 1)
model = discriminator_block(model, 128, 3, 2)
model = discriminator_block(model, 256, 3, 1)
model = discriminator_block(model, 256, 3, 2)
model = discriminator_block(model, 512, 3, 1)
model = discriminator_block(model, 512, 3, 2)
model = Flatten()(model)
model = Dense(1024)(model)
model = LeakyReLU(alpha=0.2)(model)
model = Dense(1)(model)
model = Activation('sigmoid')(model)
discriminator_model = Model(inputs=dis_input, outputs=model)
return discriminator_model
def build_model():
model = tf.keras.Sequential()
model.add(layers.Conv2D(96, kernel_size = (11,11), input_shape=(227,227,1), strides=(4,4), activation='linear', padding='valid', name='conv1'))
model.add(LeakyReLU(alpha=0.01,name='leaky_relu1'))
model.add(layers.MaxPooling2D(pool_size=3,strides=2, name='pool1'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(256, kernel_size = (5,5), activation='linear', padding='valid', name='conv2'))
model.add(LeakyReLU(alpha=0.01,name='leaky_relu2'))
model.add(layers.MaxPooling2D(pool_size=3,strides=2, name='pool2'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(384, kernel_size = (3,3), padding='valid', name='conv3'))
model.add(LeakyReLU(alpha=0.01,name='leaky_relu3'))
model.add(layers.Conv2D(384, kernel_size = (3,3), padding='valid', name='conv4'))
model.add(LeakyReLU(alpha=0.01,name='leaky_relu4'))
model.add(layers.Conv2D(256, kernel_size = (3,3), padding='valid', name='conv5'))
model.add(LeakyReLU(alpha=0.01,name='leaky_relu5'))
model.add(layers.MaxPooling2D(pool_size=2,strides=2, name='pool3'))
model.add(layers.Flatten())
model.add(layers.Dense(1024, name='dense1'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1024, name='dense2'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, name='dense3', activation='softmax'))
return model
def create_generator():
model = Sequential()
# Reshape input into 32x32x256 tensor via a fully connected layer
model.add(Dense(64 * 32 * 32, input_dim=z_dim))
model.add(Reshape((32, 32, 64)))
model.add(
Conv2DTranspose( # Transposed convolution layer, from 32x32x256 into 64x64x128 tensor
128,
kernel_size=3,
strides=2,
padding='same'))
model.add(BatchNormalization()) # Batch normalization
model.add(LeakyReLU(alpha=0.01)) # Leaky ReLU
model.add(
Conv2DTranspose( # Transposed convolution layer, from 64x64x128 to 128x128x64 tensor
64,
kernel_size=3,
strides=2,
padding='same'))
model.add(BatchNormalization()) # Batch normalization
model.add(LeakyReLU(alpha=0.01)) # Leaky ReLU
model.add(
Conv2DTranspose( # Transposed convolution layer, from 128x128x64 to 256x256x3 tensor
3,
kernel_size=3,
strides=2,
padding='same'))
model.add(Activation('tanh')) # Tanh activation
model.compile(loss='binary_crossentropy', optimizer=adam_optimizer())
model.summary()
return model
def create_discriminator():
model = Sequential()
model.add(
Conv2D(32,
kernel_size=3,
strides=2,
padding="same",
input_shape=(256, 256, 3)))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(BatchNormalization(momentum=0.8))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(BatchNormalization(momentum=0.8))
model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(BatchNormalization(momentum=0.8))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=adam_optimizer())
model.summary()
return model
def discriminator_model():
"""Build discriminator architecture."""
n_layers, use_sigmoid = 3, False
inputs = Input(shape=input_shape_discriminator)
x = Conv2D(filters=ndf, kernel_size=(4, 4), strides=2, padding='same')(inputs)
x = LeakyReLU(0.2)(x)
nf_mult, nf_mult_prev = 1, 1
for n in range(n_layers):
nf_mult_prev, nf_mult = nf_mult, min(2**n, 8)
x = Conv2D(filters=ndf*nf_mult, kernel_size=(4, 4), strides=2, padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
nf_mult_prev, nf_mult = nf_mult, min(2**n_layers, 8)
x = Conv2D(filters=ndf*nf_mult, kernel_size=(4, 4), strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
x = Conv2D(filters=1, kernel_size=(4, 4), strides=1, padding='same')(x)
if use_sigmoid:
x = Activation('sigmoid')(x)
x = Flatten()(x)
x = Dense(1024, activation='tanh')(x)
x = Dense(1, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=x, name='Discriminator')
return model
def build_discriminator(self):
'''
This function is used to define the discriminator of model(DCGAN).
'''
model = Sequential()
model.add(Reshape((self.img_size, self.img_size, self.img_channels)))
model.add(Conv2D(32, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(64, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
#model.add(ZeroPadding2D(padding = ((0,1),(0,1))))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(128, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
#model.add(ZeroPadding2D(padding = ((0,1),(0,1))))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(128, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Flatten())
model.add(Dense(1, activation = 'sigmoid'))
img = Input(shape = (self.img_size, self.img_size, self.img_channels))
output_ = model(img)
return Model(img, output_)
def bbox_3D_net(input_shape=(224, 224, 3), vgg_weights=None, freeze_vgg=False, bin_num=6):
vgg16_model = VGG16(include_top=False, weights=vgg_weights, input_shape=input_shape)
if freeze_vgg:
for layer in vgg16_model.layers:
layer.trainable = False
x = Flatten()(vgg16_model.output)
dimension = Dense(512)(x)
dimension = LeakyReLU(alpha=0.1)(dimension)
dimension = Dropout(0.5)(dimension)
dimension = Dense(3)(dimension)
dimension = LeakyReLU(alpha=0.1, name='dimension')(dimension)
orientation = Dense(256)(x)
orientation = LeakyReLU(alpha=0.1)(orientation)
orientation = Dropout(0.5)(orientation)
orientation = Dense(bin_num * 2)(orientation)
orientation = LeakyReLU(alpha=0.1)(orientation)
orientation = Reshape((bin_num, -1))(orientation)
orientation = Lambda(l2_normalize, name='orientation')(orientation)
confidence = Dense(256)(x)
confidence = LeakyReLU(alpha=0.1)(confidence)
confidence = Dropout(0.5)(confidence)
confidence = Dense(bin_num, activation='softmax', name='confidence')(confidence)
model = Model(vgg16_model.input, outputs=[dimension, orientation, confidence])
return model
def f(up, conv):
concat = concatenate([up, conv], axis=-1)
conv = Conv2D(filters, strides, padding=padding)(concat)
conv = LeakyReLU(alpha=0.3)(conv)
conv = Dropout(0.2)(conv)
conv = Conv2D(filters, strides, padding=padding)(conv)
conv = LeakyReLU(alpha=0.3)(conv)
return conv
def __init__(self, latent_dim, original_dim):
super(Decoder, self).__init__()
# decoder sub layers
self.hidden_layer1 = Dense(
units=latent_dim, activation='relu', kernel_initializer='he_uniform')
self.bn1 = BatchNormalization()
self.leakyr1 = LeakyReLU()
self.hidden_layer2 = Dense(units=32, activation='relu')
self.bn2 = BatchNormalization()
self.leakyr2 = LeakyReLU()
self.output_layer = Dense(units=original_dim, activation='sigmoid')
def conv_I(self, inputs):
shortcut = inputs
inputs = Conv2D(filters=32, kernel_size=1, strides=1, padding='SAME',
name='CONV_I',kernel_initializer='glorot_uniform',
use_bias=False)(inputs)
inputs = self.batch_norm(inputs)
inputs = LeakyReLU(alpha=_LEAKY_RELU)(inputs)
inputs = Conv2D(filters=64, kernel_size=3, strides=1, padding='SAME',
kernel_initializer='glorot_uniform', use_bias=False)(inputs)
inputs = self.batch_norm(inputs)
inputs = Add()([inputs, shortcut])
inputs = LeakyReLU(alpha=_LEAKY_RELU)(inputs)
return inputs
def __init__(self, input_dim):
super(Encoder, self).__init__()
self.output_dim = 16 # bottleneck size
# encoder sub layers
self.hidden_layer1 = Dense(
units=64, activation='relu', kernel_initializer='he_uniform', input_dim=input_dim)
self.bn1 = BatchNormalization()
self.leakyr1 = LeakyReLU()
self.hidden_layer2 = Dense(units=32, activation='relu')
self.bn2 = BatchNormalization()
self.leakyr2 = LeakyReLU()
self.output_layer = Dense(units=self.output_dim, activation='sigmoid')
def discriminator_network(shape):
input_ab = Input(shape=(*shape, 2), name='d_ab_input')
input_l = Input(shape=(*shape, 1), name='d_l_input')
net = concatenate([input_l, input_ab], name='d_concat')
net = Conv2D(64, (4, 4), padding='same', strides=(2, 2), name='d_conv2d_1')(net) # 112, 112, 64
net = LeakyReLU(name='leakyrelu_1')(net)
net = Conv2D(128, (4, 4), padding='same', strides=(2, 2), name='d_conv2d_2')(net) # 56, 56, 128
net = LeakyReLU(name='leakyrelu_2')(net)
net = Conv2D(256, (4, 4), padding='same', strides=(2, 2), name='d_conv2d_3')(net) # 28, 28, 256
net = LeakyReLU(name='leakyrelu_3')(net)
net = Conv2D(512, (4, 4), padding='same', strides=(1, 1), name='d_conv2d_4')(net) # 28, 28, 512
net = LeakyReLU(name='leakyrelu_4')(net)
net = Conv2D(1, (4, 4), padding='same', strides=(1, 1), name='d_conv2d_5')(net) # 28, 28,1
return Model([input_ab, input_l], net)
def create_generator():
generator = Sequential()
generator.add(Dense(units=256, input_dim=100))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=512))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=1024))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=784, activation='tanh'))
generator.compile(loss='binary_crossentropy', optimizer=adam_optimizer())
return generator
def build_discriminator(data_dim, num_classes):
model = Sequential()
model.add(Dense(31, input_dim=data_dim))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dropout(0.25))
model.add(Dense(16, input_dim=data_dim))
model.add(LeakyReLU(alpha=0.2))
model.summary()
trans = Input(shape=(data_dim,))
features = model(trans)
valid = Dense(1, activation="sigmoid")(features)
label = Dense(num_classes+1, activation="softmax")(features)
return Model(trans, [valid, label])
def build_discriminator(self):
model = Sequential()
model.add(Flatten(input_shape=self.img_shape))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(256))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(1, activation='sigmoid'))
model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def generator_model(shape):
generator = Sequential()
generator.add(Dense(units=256, input_dim=shape))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=512))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=1024))
generator.add(LeakyReLU(0.2))
generator.add(Dense(units=shape, activation='tanh'))
generator.compile(loss='binary_crossentropy', optimizer='adam')
return generator
def conv(self,
inp,
filters,
kernel_size=5,
strides=2,
padding="same",
use_instance_norm=False,
res_block_follows=False,
**kwargs):
""" Convolution Layer"""
logger.debug(
"inp: %s, filters: %s, kernel_size: %s, strides: %s, use_instance_norm: %s, "
"kwargs: %s)", inp, filters, kernel_size, strides,
use_instance_norm, kwargs)
name = self.get_name("conv_{}".format(inp.shape[1]))
if self.use_reflect_padding:
inp = ReflectionPadding2D(
stride=strides,
kernel_size=kernel_size,
name="{}_reflectionpadding2d".format(name))(inp)
padding = "valid"
var_x = self.conv2d(inp,
filters,
kernel_size=kernel_size,
strides=strides,
padding=padding,
name="{}_conv2d".format(name),
**kwargs)
if use_instance_norm:
var_x = InstanceNormalization(
name="{}_instancenorm".format(name))(var_x)
if not res_block_follows:
var_x = LeakyReLU(0.1, name="{}_leakyrelu".format(name))(var_x)
return var_x
def build_model(self):
inputs = Input((self.patch_height, self.patch_width, 1))
conv1 = self.encoding_block(32, strides=(3, 3), padding='same')(inputs)
conv1 = self.se_block(ratio=2)(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = self.encoding_block(64, strides=(3, 3), padding='same')(pool1)
conv2 = self.se_block(ratio=2)(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = self.encoding_block(128, strides=(3, 3), padding='same')(pool2)
conv3 = self.se_block(ratio=2)(conv3)
up = UpSampling2D(size=(2, 2))(conv3)
conv4 = decoding_block(filters, strides=(3, 3), padding='same')(up,
conv2)
conv4 = self.se_block(ratio=2)(conv4)
up1 = UpSampling2D(size=(2, 2))(conv4)
conv5 = decoding_block(filters, strides=(3, 3), padding='same')(up1,
conv1)
conv5 = self.se_block(ratio=2)(conv5)
conv6 = Conv2D(self.num_seg_class + 1, (1, 1), padding='same')(conv5)
conv6 = LeakyReLU(alpha=0.3)(conv6)
conv6 = core.Reshape((self.patch_height * self.patch_width,
self.num_seg_class + 1))(conv6)
act = Activation('softmax')(conv6)
model = Model(inputs=inputs, outputs=act)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
plot_model(model,
to_file=os.path.join(self.config.checkpoint, "model.png"),
show_shapes=True)
self.model = model
def block(out,
nkernels,
down=True,
bn=True,
dropout=False,
leaky=True,
normalization=InstanceNormalization):
if leaky:
out = LeakyReLU(0.2)(out)
else:
out = Activation('relu')(out)
if down:
out = ZeroPadding2D((1, 1))(out)
out = Conv2D(nkernels,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False)(out)
else:
out = Conv2DTranspose(nkernels,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False)(out)
out = Cropping2D((1, 1))(out)
if bn:
out = normalization(axis=-1)(out)
if dropout:
out = Dropout(0.5)(out)
return out
def d_layer(layer_input, filters, f_size=4, bn=True):
"""Discriminator layer"""
d = Conv2D(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
def conv_III(self, inputs):
shortcut = inputs
for _ in range(4):
inputs = Conv2D(filters=128, kernel_size=1, strides=1,
padding='SAME', kernel_initializer='glorot_uniform', use_bias=False)(inputs)
inputs = self.batch_norm(inputs)
inputs = LeakyReLU(alpha=_LEAKY_RELU)(inputs)
inputs = Conv2D(filters=128, kernel_size=3, strides=1, padding='SAME',
kernel_initializer='glorot_uniform', use_bias=False)(inputs)
inputs = self.batch_norm(inputs)
inputs = Add()([inputs, shortcut])
inputs = LeakyReLU(alpha=_LEAKY_RELU)(inputs)
shortcut = inputs
return inputs
def DarknetConv2D_BN_Leaky(*args, **kwargs):
# batch normalization を使用する場合、畳み込み層の bias は不要である。
no_bias_kwargs = {'use_bias': False}
# num_blocks 個の residual block を作成する。
no_bias_kwargs.update(kwargs)
return compose(DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(), LeakyReLU(alpha=0.1))
def discriminator():
model = Sequential()
model.add(
Conv2D(1,
kernel_size=(5, 5),
strides=(2, 2),
padding='same',
input_shape=(_WIDTH, _HEIGHT, 1)))
model.add(LeakyReLU())
model.add(Conv2D(16, kernel_size=(5, 5), strides=(2, 2), padding='same'))
model.add(LeakyReLU())
model.add(Conv2D(24, kernel_size=(5, 5), strides=(2, 2), padding='same'))
model.add(LeakyReLU())
model.add(Flatten())
model.add(Dense(1))
return model
def build_discriminator(self):
model = Sequential()
model.add(
CuDNNLSTM(512, input_shape=self.seq_shape, return_sequences=True))
model.add(Bidirectional(CuDNNLSTM(512)))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(256))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(1, activation='sigmoid'))
model.summary()
seq = Input(shape=self.seq_shape)
validity = model(seq)
return Model(seq, validity)
def discriminator_model(shape):
discriminator = Sequential()
discriminator.add(Dense(units=1024, input_dim=shape))
discriminator.add(LeakyReLU(0.2))
discriminator.add(Dropout(0.3)) #to prevent overfitting
discriminator.add(Dense(units=512))
discriminator.add(LeakyReLU(0.2))
discriminator.add(Dropout(0.3)) #to prevent overfitting
discriminator.add(Dense(units=256))
discriminator.add(LeakyReLU(0.2))
discriminator.add(Dense(units=1, activation='sigmoid'))
discriminator.compile(loss='binary_crossentropy', optimizer='adam')
return discriminator
def conv2d(layer_input, filters, f_size=4, bn=True):
"""Layers used during downsampling"""
d = Conv2D(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
def __init__(self, fltr, fltr_pre):
super(EncoderBlock_s_conv, self).__init__()
self.fltr = fltr
self.fltr_pre = fltr_pre
self.fc = layers.Dense(self.fltr_pre)
self.add = layers.Add()
self.lrelu = LeakyReLU()
self.conv = Conv2d(self.fltr)
