def crop(output1, output2, i):
o_shape2 = keras.Model(i, output2).output_shape
output_height2 = o_shape2[1]
output_width2 = o_shape2[2]
o_shape1 = keras.Model(i, output1).output_shape
output_height1 = o_shape1[1]
output_width1 = o_shape1[2]
cx = abs(output_width1 - output_width2)
cy = abs(output_height2 - output_height1)
if output_width1 > output_width2:
output1 = layers.Cropping2D(cropping=((0, 0), (0, cx)), data_format=IMAGE_ORDERING)(output1)
else:
output2 = layers.Cropping2D(cropping=((0, 0), (0, cx)), data_format=IMAGE_ORDERING)(output2)
if output_height1 > output_height2:
output1 = layers.Cropping2D(cropping=((0, cy), (0, 0)), data_format=IMAGE_ORDERING)(output1)
else:
output2 = layers.Cropping2D(cropping=((0, cy), (0, 0)), data_format=IMAGE_ORDERING)(output2)
return output1, output2
def deconv_stage1(self, x, before_pooling):
x = UnPooling()([before_pooling, x],
pool_size=(1, 3, 3, 1),
strides=(1, 2, 2, 1))
x = layers.Cropping2D(1)(x)
x = layers.BatchNormalization(axis=3, name='bn_conv1')(x)
x = layers.Conv2DTranspose(3, (7, 7),
strides=(2, 2),
padding='valid',
activation='relu',
name='conv1',
use_bias=False)(x)
x = layers.Cropping2D(3)(x)
return x
def make_generator():
noise = layers.Input(shape=(noise_dim, ))
x = layers.Dense(4 * 4 * 256, use_bias=False)(noise)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(0.2)(x)
x = layers.Reshape((4, 4, 256))(x)
x = upsample_block(x,
128,
layers.LeakyReLU(0.2),
strides=(1, 1),
use_bias=False,
use_bn=True,
padding="same",
use_dropout=False)
x = upsample_block(x,
64,
layers.LeakyReLU(0.2),
strides=(1, 1),
use_bias=False,
use_bn=True,
padding="same",
use_dropout=False)
x = upsample_block(x,
1,
layers.Activation("tanh"),
strides=(1, 1),
use_bias=False,
use_bn=True)
x = layers.Cropping2D((2, 2))(x)
g_model = keras.models.Model(noise, x, name="generator")
return g_model
def __init__(self,
kernel_size,
filters,
instanceNorm=True,
regularizer=None):
super(ResnetIdentityBlock, self).__init__()
filters1, filters2 = filters
self.instanceNorm = instanceNorm
self.conv2a = layers.Conv2D(filters1,
kernel_size,
padding='valid',
kernel_regularizer=regularizer,
bias_regularizer=regularizer)
if instanceNorm is False:
self.norm2a = layers.BatchNormalization(
beta_regularizer=regularizer, gamma_regularizer=regularizer)
else:
self.norm2a = InstanceNormalization()
self.relu2a = layers.ReLU()
self.conv2b = layers.Conv2D(filters2,
kernel_size,
padding='valid',
kernel_regularizer=regularizer,
bias_regularizer=regularizer)
if instanceNorm is False:
self.norm2b = layers.BatchNormalization(
beta_regularizer=regularizer, gamma_regularizer=regularizer)
else:
self.norm2b = InstanceNormalization()
self.crop2d = layers.Cropping2D(cropping=2)
def _fit(src: Optional[Tensor], tgt: Tensor, num_filters: int,
name: str) -> Tensor:
if src is None:
# Directly return target because there is nothing to fit
return tgt
if src.shape[2] == tgt.shape[2]:
# Feature map shapes match, squeeze channels
return _squeeze(src, num_filters, name + '_squeeze')
# Shape does not match, down-sample source feature map
x = layers.ReLU(name=name + '_relu')(src)
p1 = layers.AveragePooling2D(pool_size=1, strides=2,
name=name + '_pool1')(x)
p1 = layers.Conv2D(num_filters // 2,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2_reg,
name=name + '_conv1')(p1)
p2 = layers.ZeroPadding2D(padding=((0, 1), (0, 1)), name=name + '_pad')(x)
p2 = layers.Cropping2D(cropping=((1, 0), (1, 0)), name=name + '_crop')(p2)
p2 = layers.AveragePooling2D(pool_size=1, strides=2,
name=name + '_pool2')(p2)
p2 = layers.Conv2D(num_filters // 2,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2_reg,
name=name + '_conv2')(p2)
x = layers.concatenate([p1, p2], name=name + '_concat')
x = layers.BatchNormalization(epsilon=bn_eps,
gamma_regularizer=l2_reg,
name=name + '_bn')(x)
return x
def __init__(self,
in_channels,
out_channels,
kernel_size,
strides=1,
padding=0,
out_padding=0,
dilation=1,
groups=1,
use_bias=True,
data_format="channels_last",
**kwargs):
super(Deconv2d, self).__init__(**kwargs)
assert (dilation == 1)
assert (groups == 1)
assert (in_channels is not None)
if isinstance(padding, int):
padding = (padding, padding)
self.use_crop = (padding[0] > 0) or (padding[1] > 0)
if self.use_crop:
self.crop = nn.Cropping2D(cropping=padding,
data_format=data_format,
name="crop")
self.conv = nn.Conv2DTranspose(filters=out_channels,
kernel_size=kernel_size,
strides=strides,
padding="valid",
output_padding=out_padding,
data_format=data_format,
dilation_rate=dilation,
use_bias=use_bias,
name="conv")
def get_model2(l2=0.001):
model = Sequential()
model.add(
layers.Cropping2D(cropping=((50, 20), (0, 0)),
input_shape=(160, 320, 3)))
model.add(layers.Lambda(lambda x: x / 255.0 - 0.5))
# 160 x 320 x 3
model.add(
layers.Conv2D(24, 5, strides=2, padding='valid', activation='relu'))
# 78 x 158 x 24
model.add(
layers.Conv2D(36, 5, strides=2, padding='valid', activation='relu'))
# 37 x 77 x 36
model.add(
layers.Conv2D(48, 5, strides=2, padding='valid', activation='relu'))
# 17 x 37 x 48
model.add(
layers.Conv2D(64, 3, strides=1, padding='valid', activation='relu'))
# 8 x 18 x 64
model.add(
layers.Conv2D(64, 3, strides=1, padding='valid', activation='relu'))
#model.add(layers.Dropout(0.3))
# 3 x 8 x 64
model.add(layers.Flatten())
#model.add(layers.Dense(512, activation='relu'))
#model.add(layers.Dropout(0.5))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(12, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(1))
return model
def build_conv_ae(dim, channels, latent_dim, learning_rate=1e-3, loss_func=mae):
if dim < 16:
raise ValueError("Image dimensions must be at least 16x16.")
if channels < 1:
raise ValueError("Channels must be a positive integer.")
if latent_dim < 1:
raise ValueError("Latent dimension must be a positive integer.")
# input layer
input_layer = layers.Input((dim, dim, channels))
X = input_layer
# conv layers
half_dim = dim
counter = 0
# Encoding
while half_dim >= 8:
# make layers
# Conv2D(num_channels, window size, stride)
X = layers.Conv2D(16*2**(counter), 3, 1, padding='same')(X)
X = layers.BatchNormalization()(X)
X = layers.Activation('relu')(X)
X = layers.Conv2D(16*2**(counter), 3, 1, padding='same')(X)
X = layers.BatchNormalization()(X)
X = layers.Activation('relu')(X)
X = layers.MaxPooling2D(2, 2, padding="same")(X)
counter += 1
half_dim = np.ceil(half_dim / 2)
# End of encoding
X = layers.Flatten()(X)
latent_space = layers.Dense(latent_dim, activation="tanh")(X)
X = layers.Dense(half_dim * half_dim * 16*2**(counter))(latent_space)
X = layers.Reshape((half_dim, half_dim, 16*2**(counter)))(X)
for i in range(counter):
X = layers.Conv2DTranspose(16*2**(counter-i), 4, 2, padding='same')(X)
X = layers.BatchNormalization()(X)
X = layers.Activation('relu')(X)
X = layers.Conv2DTranspose(16*2**(counter-i), 3, 1, padding='same')(X)
X = layers.BatchNormalization()(X)
X = layers.Activation('relu')(X)
X = layers.Conv2D(channels, 5, 1, padding='same')(X)
X = layers.Activation('sigmoid')(X)
# crop layer
reconstructed_dim = half_dim * 2 ** counter
left_diff = int((reconstructed_dim-dim) / 2)
right_diff = (reconstructed_dim-dim) - left_diff
output_layer = layers.Cropping2D(((left_diff, right_diff), (left_diff, right_diff)))(X)
# output layer
model = models.Model(input_layer, output_layer)
model.compile(Adam(learning_rate), loss=loss_func)
return model
def cnn_unet(inputs, filters=64, num_layers=4):
# array to hold outputs of blocks
# in the contracting path
# for later use
# in the expanding path
down_blocks = []
# build the contracting path
# Create the downsampling layers
net = inputs
for i in range(num_layers):
name = f'contract_{i+1}'
net = unet_conv_block(inputs=net,
filters=filters,
padding='valid',
name=name)
# save this layer for later reference
down_blocks.append(net)
# add pooling
net = layers.MaxPooling2D((2, 2), strides=2, name=f'{name}_pool')(net)
# increase the number of filters
filters = filters * 2
# build the lateral path
net = unet_conv_block(inputs=net,
filters=filters,
padding='valid',
name='lateral')
# build the expanding path
i = num_layers
for conv in reversed(down_blocks):
# decrease the number of filters
filters = filters // 2
name = f'expand_{i}'
# upsample
net = layers.Conv2DTranspose(filters, (2, 2),
strides=(2, 2),
padding='valid',
name=f'{name}_upconv')(net)
# identify the center crop area
center_crop = get_center_crop_location(source=conv, destination=net)
# perform cropping
conv = layers.Cropping2D(cropping=center_crop,
name=f'{name}_crop')(conv)
# concatenate
net = layers.concatenate([net, conv], name=f'{name}_concatenate')
# add one more convolutional block
net = unet_conv_block(inputs=net,
filters=filters,
padding='valid',
name=name)
i = i - 1
# we are done
return net
def simple_net(input_shape):
m = models.Sequential()
m.add(layers.Lambda(lambda x: x / 127.5 - 1., input_shape=input_shape))
m.add(layers.Cropping2D(cropping=((50, 20), (0, 0))))
m.add(layers.Convolution2D(24, 5, 5, activation='relu'))
m.add(layers.MaxPooling2D())
m.add(layers.Flatten())
m.add(layers.Dense(120))
m.add(layers.Dense(1))
return m
def up_conv(x, skip, filter_size, similar=False):
"""
up convolution
Args:
x (tensor): input tensor
skip (tensor): residual connection
filter_size (int): filter size
similar (bool): similar size restoration?
Returns: keras tensor
"""
x = layers.Conv2DTranspose(
filter_size,
2,
2,
padding='same'
)(x)
image_size = tf.keras.backend.int_shape(x)[1]
skip_size = tf.keras.backend.int_shape(skip)[1]
crop_size = (skip_size - image_size) // 2
cropped_tuple = (crop_size, crop_size)
# make proper cropping to skip connections or zero padding to x's based
# on whether similar or different input-ouput sizes are expected!
if (skip_size - image_size) % 2:
crop_size = crop_size
cropped_tuple = ((crop_size, crop_size+1), (crop_size+1, crop_size))
if not similar: # just like original unet paper
skip = layers.Cropping2D(
cropped_tuple
)(skip)
padding='valid'
else: # zero padding to x
x = layers.ZeroPadding2D(
cropped_tuple
)(x)
padding='same'
x = layers.Concatenate()([skip, x])
for i in range(2):
x = layers.Conv2D(
filter_size,
3,
1,
padding=padding,
activation='relu'
)(x)
return x
def fcn8_decoder(convs, n_classes):
f1, f2, f3, f4, f5, = convs
o = layers.Conv2DTranspose(n_classes,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False)(f5)
o = layers.Cropping2D(cropping=(1, 1))(o)
o2 = f4
o2 = (layers.Conv2D(n_classes,
(1, 1),
activation='relu',
padding='same'))(o2)
o = layers.Add()([o, o2])
o = (layers.Conv2DTranspose(n_classes,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False))(o)
o = layers.Cropping2D(cropping=(1, 1))(o)
o2 = (layers.Conv2D(n_classes,
(1, 1),
activation='relu',
padding='same'))(f3)
o = layers.Add()([o, o2])
o = layers.Conv2DTranspose(n_classes,
kernel_size=(8, 8),
strides=(8, 8),
use_bias=False)(o)
o = layers.Activation('softmax')(o)
return o
def pad_to_scale(self, x, scale, size=300):
expected = int(np.ceil(size / (2.**scale)))
diff = expected - int(x.shape[1])
if diff > 0:
left = diff // 2
right = diff - left
x = self.reflectpad(x, (left, right))
elif diff < 0:
left = -diff // 2
right = -diff - left
x = layers.Cropping2D(((left, right), (left, right)))(x)
return x
def decoder_block(x,
x_skip,
filters,
kernel_size,
padding='same',
dilation_rate=1):
"""
Decoder block used in expansive path of UNet.
"""
x = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(x)
# Calculate cropping for down_tensor to concatenate with x
if x_skip is not None:
_, h2, w2, _ = x_skip.shape
_, h1, w1, _ = x.shape
h_diff, w_diff = h2 - h1, w2 - w1
cropping = ((int(tf.math.ceil(h_diff / 2)),
int(tf.math.floor(h_diff / 2))),
(int(tf.math.ceil(w_diff / 2)),
int(tf.math.floor(w_diff / 2))))
x_skip = layers.Cropping2D(cropping=cropping)(x_skip)
x = layers.concatenate([x, x_skip], axis=3)
x = conv2d_block(x,
filters,
kernel_size,
padding,
dilation_rate,
batch_norm=True,
activation='relu')
x = conv2d_block(x,
filters,
kernel_size,
padding,
dilation_rate,
batch_norm=True,
activation='relu')
x = conv2d_block(x,
filters,
kernel_size,
padding,
dilation_rate,
batch_norm=True,
activation='relu')
return x
def call(self, x, down_tensor=None):
x = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(x)
# Calculate cropping for down_tensor to concatenate with x
if down_tensor is not None:
_, h2, w2, _ = down_tensor.shape
_, h1, w1, _ = x.shape
h_diff, w_diff = h2 - h1, w2 - w1
cropping = ((int(np.ceil(h_diff / 2)), int(np.floor(h_diff / 2))),
(int(np.ceil(w_diff / 2)), int(np.floor(w_diff / 2))))
down_tensor = layers.Cropping2D(cropping=cropping)(down_tensor)
x = layers.concatenate([x, down_tensor], axis=3)
x = self.decode(x)
return x
def nvidia_model(input_shape, dropout):
m = models.Sequential()
m.add(layers.Lambda(lambda x: x / 255.0 - 0.5, input_shape=input_shape))
m.add(layers.Cropping2D(cropping=((70, 25), (0, 0))))
m.add(layers.Convolution2D(24, 5, 2, activation='relu'))
m.add(layers.Convolution2D(36, 5, 2, activation='relu'))
m.add(layers.Convolution2D(48, 5, 2, activation='relu'))
m.add(layers.Dropout(dropout))
m.add(layers.Convolution2D(64, 3, activation='relu'))
m.add(layers.Convolution2D(64, 3, activation='relu'))
m.add(layers.Flatten())
m.add(layers.Dense(100))
m.add(layers.Dropout(dropout))
m.add(layers.Dense(50))
m.add(layers.Dense(10))
m.add(layers.Dense(1))
return m
def get_generator_model(noise_dim):
noise = layers.Input(shape=(noise_dim, ))
x = layers.Dense(4 * 4 * 256, use_bias=False)(noise)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(0.2)(x)
x = layers.Reshape((4, 4, 256))(x)
x = upsample_block(
x,
128,
layers.LeakyReLU(0.2),
strides=(1, 1),
use_bias=False,
use_bn=True,
padding="same",
use_dropout=False,
)
x = upsample_block(
x,
64,
layers.LeakyReLU(0.2),
strides=(1, 1),
use_bias=False,
use_bn=True,
padding="same",
use_dropout=False,
)
x = upsample_block(
x,
1,
layers.Activation("tanh"),
strides=(1, 1),
use_bias=False,
use_bn=True,
)
# At this point, we have an output which has the same shape as the
# input, (32, 32, 1). We will use a Cropping2D layer to make it
# (28, 28, 1).
x = layers.Cropping2D((2, 2))(x)
g_model = keras.models.Model(noise, x, name="generator")
return g_model
def make_generator_model():
#input layer
model = tf.keras.Sequential()
model.add(Dense(4 * 4 * 256, use_bias=False, input_shape=(100, )))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(0.2))
model.add(layers.Reshape((4, 4, 256)))
assert model.output_shape == (None, 4, 4, 256)
#layer 1
model.add(layers.UpSampling2D((2, 2)))
model.add(
layers.Conv2DTranspose(128, (3, 3),
strides=(1, 1),
padding='same',
use_bias=False))
assert model.output_shape == (None, 8, 8, 128) #maybe wrong
model.add(layers.LeakyReLU(0.2))
#layer 2
model.add(layers.UpSampling2D((2, 2)))
model.add(
layers.Conv2DTranspose(64, (3, 3),
strides=(1, 1),
padding='same',
use_bias=False))
assert model.output_shape == (None, 16, 16, 64)
model.add(layers.LeakyReLU(0.2))
#layer 3 / output layer
model.add(layers.UpSampling2D((2, 2)))
model.add(
layers.Conv2DTranspose(1, (3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh'))
assert model.output_shape == (None, 32, 32, 1)
model.add(layers.Cropping2D((2, 2)))
return model
def build_model():
#Encoder
model = tf.keras.Sequential()
model.add(layers.Conv2D(32,kernel_size = (3,3), input_shape = (227,227,1), activation='relu', name='conv_autoencoder1', padding='same'))
model.add(layers.MaxPooling2D(pool_size=2, strides = 2, padding='same',name='pool_autoencoder1'))
model.add(layers.Conv2D(16, kernel_size=(3,3), activation='relu', name='conv_autoencoder2', padding='same'))
model.add(layers.MaxPooling2D(pool_size=2,strides = 2, padding='same',name='pool_autoencoder2'))
model.add(layers.Conv2D(30, kernel_size=(3,3), activation='relu', name='conv_autoencoder3', padding='same'))
model.add(layers.MaxPooling2D(pool_size=2,strides = 2, padding='same',name='pool_autoencoder3'))
#Decoder
model.add(layers.Conv2D(30, kernel_size=(3,3), activation='relu', name='conv_autoencoder4', padding='same'))
model.add(layers.UpSampling2D((2,2), name='up_autoencoder1'))
model.add(layers.Conv2D(16, kernel_size=(3,3), activation='relu', name='conv_autoencoder5', padding='same'))
model.add(layers.UpSampling2D((2,2), name='up_autoencoder2'))
model.add(layers.Conv2D(32, kernel_size=(3,3), activation='relu', name='conv_autoencoder6', padding='same'))
model.add(layers.UpSampling2D((2,2),name='up_autoencoder3'))
model.add(layers.Conv2D(1,(3,3),activation='linear',padding='same',name='conv_autoencoder7'))
model.add(layers.Cropping2D(((0,5),(0,5)),name='crop'))
return model
def conv2d_stats_block(input_layer, cropping, stats_block):
x = layers.Cropping2D(cropping, name='crop_' + stats_block)(input_layer)
x = layers.Conv2D(8, (5, 5), (2, 2), name='conv2d_' + stats_block)(x)
x = layers.BatchNormalization(name='batchnorm_' + stats_block)(x)
x = layers.MaxPool2D((2, 2))(x)
x = convolutional_block(x, 3, [8, 8, 16], 2, stats_block + '_a', s=1)
x = identity_block(x, 3, [8, 8, 16], 2, stats_block + '_b')
x = identity_block(x, 3, [8, 8, 16], 2, stats_block + '_c')
x = convolutional_block(x, 3, [16, 16, 32], 3, stats_block + '_a', s=2)
x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_b')
x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_c')
x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_d')
x = convolutional_block(x, 3, [32, 32, 64], 4, stats_block + '_a', s=2)
x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_b')
x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_c')
x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_d')
return layers.AveragePooling2D((3, 3))(x)
def __init__(self, name_prefix, filters, data_format, **kwargs):
self.name_prefix = name_prefix
self.filters = filters
self.data_format = data_format
self.relu = kl.ReLU(name=f'{name_prefix}relu_')
self.x0_avgpool = kl.AveragePooling2D(
pool_size=(1, 1),
strides=(2, 2),
padding="valid",
data_format=self.data_format,
name=f'{name_prefix}avepool2d_a_')
self.x0_conv = kl.Conv2D(filters=filters,
kernel_size=(1, 1),
strides=(1, 1),
padding="valid",
data_format=self.data_format,
name=f"{name_prefix}conv2d_a_")
self.x1_zeropad = kl.ZeroPadding2D(padding=((0, 1), (0, 1)),
data_format=self.data_format,
name=f"{name_prefix}zeropad2d_b_")
self.x1_cropping = kl.Cropping2D(cropping=((1, 0), (1, 0)),
data_format=self.data_format,
name=f"{name_prefix}crop2d_b_")
self.x1_avgpool = kl.AveragePooling2D(
pool_size=(1, 1),
strides=(2, 2),
padding="valid",
data_format=self.data_format,
name=f"{name_prefix}avepool2d_b_")
self.x1_conv = kl.Conv2D(filters=filters,
kernel_size=(1, 1),
strides=(1, 1),
padding="valid",
data_format=self.data_format,
name=f"{name_prefix}conv2d_b_")
self.concat = kl.Concatenate(name=f"{name_prefix}concat_")
self.bn = kl.BatchNormalization(name=f"{name_prefix}bn_")
super(FactorizedReduction_K, self).__init__(**kwargs)
def get_model():
model = Sequential()
model.add(
layers.Cropping2D(cropping=((50, 20), (0, 0)),
input_shape=(160, 320, 3)))
model.add(layers.Lambda(lambda x: x / 255.0 - 0.5))
model.add(layers.Conv2D(8, 3, activation='relu'))
model.add(layers.Conv2D(16, 3, activation='relu'))
model.add(layers.MaxPooling2D(2))
model.add(layers.Conv2D(32, 3, activation='relu'))
model.add(layers.Conv2D(32, 3, activation='relu'))
model.add(layers.MaxPooling2D(2))
model.add(layers.Conv2D(64, 3, activation='relu'))
model.add(layers.Conv2D(64, 3, activation='relu'))
model.add(layers.MaxPooling2D(2))
model.add(layers.Flatten())
#model.add(layers.Dense(512, activation='relu', kernel_regularizer='l2'))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(1))
return model
def make_model(input_shape):
inputs = keras.Input(shape=input_shape)
left_crop = int(input_shape[0] * 0.5)
bottom_crop = int(input_shape[1] * 0.5)
x = layers.experimental.preprocessing.Rescaling(1. / 255)(inputs)
x = layers.Cropping2D(cropping=((0, bottom_crop), (left_crop, 0)))(x)
x = layers.Conv2D(32, 3, strides=2, padding='same')(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
x = layers.MaxPool2D()(x)
x = layers.Conv2D(64, 3, padding='same')(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
x = layers.MaxPool2D()(x)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.5)(x)
outputs = layers.Dense(1, activation='sigmoid')(x)
return keras.Model(inputs, outputs)
def _build_model(self):
decoder = self._decoder()
encoder = self._encoder()
skips = encoder(self.inputs)
mobilenet_b16 = skips[-1]
skips = reversed(skips[:-1]) # all but smallest layer b16
conv = mobilenet_b16 # (8,10,320)
for up, skip in zip(decoder, skips):
conv = self.stride_up(conv, up[0], up[1]) # (16,20,512)
if conv.shape[1] == 16:
conv = layers.Cropping2D(cropping=((1, 0), (0, 0)))(conv)
conv = layers.concatenate([conv, skip])
self.output = layers.Conv2DTranspose(self.output_channels,
3,
strides=2,
padding='same',
activation='softmax')(
conv) # 64x64 -> 128x128
return Model(inputs=self.inputs, outputs=self.output)
def VanillaUnet(num_class = 1, img_shape = (256,256,3)):
concat_axis = 3
# input
inputs = layers.Input(shape = img_shape)
# Unet convolution block 1
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputs)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
# Unet convolution block 2
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
# Unet convolution block 3
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
# Unet convolution block 4
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
# Unet convolution block 5
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
# Unet up-sampling block 1; Concatenation with crop_conv4
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
# Unet up-sampling block 2; Concatenation with crop_conv3
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch,cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
# Unet up-sampling block 3; Concatenation with crop_conv2
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch,cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
# Unet up-sampling block 4; Concatenation with crop_conv1
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch,cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
ch, cw = get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1))(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
u9 = upsample(8, (2, 2), strides=(2, 2), padding='same')(c8)
u9 = layers.concatenate([u9, c1], axis=3)
u9 = layers.Dropout(dropout)(u9)
c9 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(u9)
c9 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(c9)
d = layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d)
d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d)
if NET_SCALING is not None:
d = layers.UpSampling2D(NET_SCALING)(d)
seg_model = models.Model(inputs=[input_img], outputs=[d])
print()
#print()
#print(seg_model.summary())
print()
## evalaution criteria
# dice coefficicent
def dice_coef(y_true, y_pred, smooth=1):
intersection = K.sum(y_true * y_pred, axis=[1, 2, 3])
def __init__(self, img_shape, num_class, d=32, weights=weights_url):
concat_axis = 3
inputs = layers.Input(shape=img_shape)
conv1 = layers.Conv2D(d, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(inputs)
conv1 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(pool1)
conv2 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(pool2)
conv3 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(pool3)
conv4 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = layers.Conv2D(d * 16, (3, 3),
activation='relu',
padding='same')(pool4)
conv5 = layers.Conv2D(d * 16, (3, 3),
activation='relu',
padding='same')(conv5)
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = self.get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch, cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(up6)
conv6 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = self.get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(up7)
conv7 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = self.get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(up8)
conv8 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = self.get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(up9)
conv9 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(conv9)
ch, cw = self.get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0],
cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1), activation="sigmoid")(conv9)
super().__init__(inputs=inputs, outputs=conv10)
if weights is not None:
self.load_weight_file(weights)
def UNet():
concat_axis = 3
inputss = Input((512, 512, 1))
print(inputss.shape)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputss)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
conv4 = Dropout(0.2)(conv4)
# pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
# conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
# conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
# up_conv5 = UpSampling2D(size=(2, 2))(conv5)
# ch, cw = get_crop_shape(conv4, up_conv5)
# crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4)
# up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
# conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
# conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv4)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
ch, cw = get_crop_shape(inputss, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = layers.Conv2D(1, (1, 1))(conv9)
print(conv10.shape)
# conv1 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(inputss)
# print(conv1.shape)
# conv1 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1)
# print(conv1.shape)
# pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
# print(pool1.shape)
# print('\n')
#
# conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1)
# print(conv2.shape)
# conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2)
# print(conv2.shape)
# pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
# print(pool2.shape)
# print('\n')
#
# conv3 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2)
# print(conv3.shape)
# conv3 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3)
# print(conv3.shape)
# pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
# print(pool3.shape)
# print('\n')
#
# conv4 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3)
# print(conv4.shape)
# conv4 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4)
# print(conv4.shape)
# drop4 = Dropout(0.5)(conv4)
# pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
# print(pool4.shape)
# print('\n')
# #
# # conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4)
# # print(conv5.shape)
# # conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5)
# # print(conv5.shape)
# # drop5 = Dropout(0.5)(conv5)
# # print('\n')
# #
# # up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# # UpSampling2D(size=(2, 2))(drop5))
# # print(up6.shape)
# # print(drop4.shape)
# # merge6 = merge([drop4, up6], mode='concat', concat_axis=3)
# # print('merge: ')
# # print(merge6.shape)
# # conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge6)
# # conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6)
# #
# up7 = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv4))
# merge7 = merge([conv3, up7], mode='concat', concat_axis=3)
# conv7 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7)
# conv7 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7)
#
# up8 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv7))
# merge8 = concatenate([conv2, up8], axis=3)
# conv8 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8)
# conv8 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8)
#
# up9 = Conv2D(32, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv8))
# merge9 = concatenate([conv1, up9], axis=3)
# conv9 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9)
# conv9 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9)
# conv9 = Conv2D(2, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9)
# # conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
# conv10 = Softmax()(conv9)
print("llllllllllllllllllllllllast")
Outmodel = Model(inputs=inputss, outputs=conv10)
Outmodel.summary()
print(conv10.shape)
return Outmodel
kernel_size=(3, 3),
padding="valid",
activation="relu")(l4_5)
l5 = layers.Conv2D(filters=1024,
kernel_size=(3, 3),
padding="valid",
activation="relu")(l5)
#level4
l6 = layers.Conv2DTranspose(filters=512,
kernel_size=(2, 2),
strides=(2, 2),
padding="valid")(l5)
#l6 = layers.UpSampling2D(size=(2,2),interpolation='nearest')(l5)
l4_connection = layers.Cropping2D(cropping=((4, 4), (4, 4)))(l4)
print(l6.shape)
print(l4_connection.shape)
print(l4.shape)
l6 = tf.keras.layers.concatenate([l6, l4_connection])
print(l6.shape)
#l6 = layers.Conv2D(filters=1024, kernel_size=(3,3), padding="valid", activation="relu")(l6)
l6 = layers.Conv2D(filters=512,
kernel_size=(3, 3),
padding="same",
activation="relu")(l6)
l6 = layers.Conv2D(filters=256,
kernel_size=(2, 2),
padding="same",
activation="relu")(l6)
sConv03 = cl.convBlock(256, 3, 2)(sConv02) res01 = cl.resBlock(256, 3)(sConv03) res02 = cl.resBlock(256, 3)(res01) tConv01 = cl.convTransBlock(128, 3, 2)(res02) add = layers.Add()([tConv01, sConv02]) tConv02 = cl.convTransBlock(64, 3, 2)(add) tConv03 = cl.convTransBlock(24, 3, 4)(tConv02) synt = layers.Conv2D(24, 3, padding="same")(tConv03) fft = cl.fftBlock()(synt) con = cl.conBlock()([mul, dMZ, fft]) trimmedCon = layers.Cropping2D(cropping=((3, 3), (3, 3)))(con) underChan = cl.fullChanBlock()(trimmedCon) fullChan = cl.fullChanBlock()(dL) model = models.Model(inputs=[dL, dM], outputs=[fullChan, underChan]) optimizer = optimizers.Adam() train = glob(r"C:/Datasets/*.h5") val = glob(r"C:/Datasets/*.h5") R = 4 # *2 sample_n = 32 # //2 # 'calibration center' size random = False # only applicable for uniform = False, really... uniform = False centered = False dim = (218, 170) # input dimensions
