|
import tensorflow as tf |
|
from keras import backend as K |
|
from keras.layers import Input, Dense, Conv2D, Conv2DTranspose, Flatten, Reshape, Lambda, BatchNormalization |
|
from keras.models import Model |
|
import numpy as np |
|
import threading |
|
|
|
KL = tf.keras.layers |
|
|
|
|
|
def cbam_layer(inputs_tensor=None, ratio=None): |
|
"""Source: https://blog.csdn.net/ZXF_1991/article/details/104615942 |
|
The channel attention |
|
""" |
|
channels = K.int_shape(inputs_tensor)[-1] |
|
|
|
def share_layer(inputs=None): |
|
x_ = KL.Conv2D(channels // ratio, (1, 1), strides=1, padding="valid")(inputs) |
|
x_ = KL.Activation('relu')(x_) |
|
output_share = KL.Conv2D(channels, (1, 1), strides=1, padding="valid")(x_) |
|
return output_share |
|
|
|
x_global_avg_pool = KL.GlobalAveragePooling2D()(inputs_tensor) |
|
x_global_avg_pool = KL.Reshape((1, 1, channels))(x_global_avg_pool) |
|
x_global_max_pool = KL.GlobalMaxPool2D()(inputs_tensor) |
|
x_global_max_pool = KL.Reshape((1, 1, channels))(x_global_max_pool) |
|
x_global_avg_pool = share_layer(x_global_avg_pool) |
|
x_global_max_pool = share_layer(x_global_max_pool) |
|
x = KL.Add()([x_global_avg_pool, x_global_max_pool]) |
|
x = KL.Activation('sigmoid')(x) |
|
CAM = KL.multiply([inputs_tensor, x]) |
|
output = CAM |
|
return output |
|
|
|
|
|
def res_cell(x, n_channel=64, stride=1): |
|
"""The basic unit in the VAE, cell.""" |
|
if stride == -1: |
|
|
|
skip = tf.keras.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(x) |
|
skip = Conv2D(filters=n_channel, kernel_size=(1, 1), strides=1, padding='same')(skip) |
|
x = Conv2DTranspose(filters=n_channel, kernel_size=(5, 5), strides=2, padding='same')(x) |
|
x = BatchNormalization()(x) |
|
x = tf.keras.activations.elu(x) |
|
x = Conv2DTranspose(filters=n_channel, kernel_size=(5, 5), padding='same')(x) |
|
|
|
elif stride == 2: |
|
|
|
skip = Conv2D(filters=n_channel, kernel_size=(1, 1), strides=2, padding='same')(x) |
|
x = Conv2D(filters=n_channel, kernel_size=(5, 5), strides=stride, padding='same')(x) |
|
x = BatchNormalization()(x) |
|
x = tf.keras.activations.elu(x) |
|
x = Conv2D(filters=n_channel, kernel_size=(5, 5), padding='same')(x) |
|
else: |
|
|
|
skip = tf.identity(x) |
|
x = Conv2D(filters=n_channel, kernel_size=(5, 5), strides=stride, padding='same')(x) |
|
x = BatchNormalization()(x) |
|
x = tf.keras.activations.elu(x) |
|
x = Conv2D(filters=n_channel, kernel_size=(5, 5), padding='same')(x) |
|
|
|
x = BatchNormalization()(x) |
|
x = cbam_layer(inputs_tensor=x, ratio=8) |
|
x = x + skip |
|
x = tf.keras.activations.elu(x) |
|
return x |
|
|
|
|
|
def res_block(x, n_channel=64, upsample=False, n_cells=2): |
|
"""The block is a stack of cells.""" |
|
if upsample: |
|
x = res_cell(x, n_channel=n_channel, stride=-1) |
|
else: |
|
x = res_cell(x, n_channel=n_channel, stride=2) |
|
for _ in range(n_cells - 1): |
|
x = res_cell(x, n_channel=n_channel, stride=1) |
|
return x |
|
|
|
|
|
def l1_distance(x1, x2): |
|
return tf.reduce_mean(tf.math.abs(x1 - x2)) |
|
|
|
|
|
def l1_log_distance(x1, x2): |
|
return tf.reduce_mean(tf.math.abs(tf.math.log(tf.maximum(1e-6, x1)) - tf.math.log(tf.maximum(1e-6, x2)))) |
|
|
|
|
|
img_height = 512 |
|
img_width = 256 |
|
num_channels = 1 |
|
input_shape = (img_height, img_width, num_channels) |
|
timbre_dim = 20 |
|
n_filters = 64 |
|
act = 'elu' |
|
|
|
|
|
def compute_latent(x): |
|
"""Re-parameterizing.""" |
|
mu, sigma = x |
|
batch = K.shape(mu)[0] |
|
dim = K.int_shape(mu)[1] |
|
eps = K.random_normal(shape=(batch, dim)) |
|
return mu + K.exp(sigma / 2) * eps |
|
|
|
|
|
def get_encoder(N2=0, channel_sizes=None): |
|
"""Assemble and return the VAE encoder.""" |
|
if channel_sizes is None: |
|
channel_sizes = [32, 64, 64, 96, 96, 128, 160, 216] |
|
encoder_input = Input(shape=input_shape) |
|
|
|
encoder_conv = res_block(encoder_input, channel_sizes[0], upsample=False, n_cells=1) |
|
|
|
for c in channel_sizes[1:]: |
|
encoder_conv = res_block(encoder_conv, c, upsample=False, n_cells=1 + N2) |
|
|
|
encoder = Flatten()(encoder_conv) |
|
|
|
mu_timbre = Dense(timbre_dim)(encoder) |
|
sigma_timbre = Dense(timbre_dim)(encoder) |
|
latent_vector = Lambda(compute_latent, output_shape=(timbre_dim,))([mu_timbre, sigma_timbre]) |
|
|
|
kl_loss = -0.5 * (1 + sigma_timbre - tf.square(mu_timbre) - tf.exp(sigma_timbre)) |
|
kl_loss = tf.reduce_mean(tf.reduce_sum(kl_loss, axis=1)) |
|
|
|
encoder = Model(encoder_input, [latent_vector, kl_loss]) |
|
return encoder |
|
|
|
|
|
def get_decoder(N2=0, N3=8, channel_sizes=None): |
|
"""Assemble and return the VAE decoder.""" |
|
if channel_sizes is None: |
|
channel_sizes = [32, 64, 64, 96, 96, 128, 160, 216] |
|
conv_shape = [-1, 2 ** (9 - N3), 2 ** (8 - N3), channel_sizes[-1]] |
|
decoder_input = Input(shape=(timbre_dim,)) |
|
|
|
decoder = Dense(conv_shape[1] * conv_shape[2] * conv_shape[3], activation=act)(decoder_input) |
|
decoder_conv = Reshape((conv_shape[1], conv_shape[2], conv_shape[3]))(decoder) |
|
|
|
for c in list(reversed(channel_sizes))[1:]: |
|
decoder_conv = res_block(decoder_conv, c, upsample=True, n_cells=1 + N2) |
|
|
|
decoder_conv = Conv2DTranspose(filters=num_channels, kernel_size=5, strides=2, |
|
padding='same', activation='sigmoid')(decoder_conv) |
|
|
|
decoder = Model(decoder_input, decoder_conv) |
|
return decoder |
|
|
|
|
|
def VAE(N2=0, N3=8, channel_sizes=None): |
|
"""Assemble and return the VAE.""" |
|
if channel_sizes is None: |
|
channel_sizes = [32, 64, 64, 96, 96, 128, 160, 216] |
|
print("Creating model...") |
|
assert N2 >= 0, "Please set N2 >= 0" |
|
assert N3 >= 1, "Please set 1 <= N3 <= 8" |
|
assert N3 <= 8, "Please set 1 <= N3 <= 8" |
|
assert N3 == len(channel_sizes), "Please set N3 = len(channel_sizes)" |
|
encoder = get_encoder(N2, channel_sizes) |
|
decoder = get_decoder(N2, N3, channel_sizes) |
|
|
|
|
|
|
|
|
|
encoder_input1 = Input(shape=input_shape) |
|
scalar_input1 = Input(shape=(1,)) |
|
|
|
embedding_1_timbre, kl_loss = encoder(encoder_input1) |
|
reconstruction_1 = decoder(embedding_1_timbre) |
|
|
|
VAE = Model([encoder_input1, scalar_input1], [reconstruction_1, kl_loss]) |
|
|
|
VAE.summary() |
|
return encoder, decoder, VAE |
|
|
|
|
|
def my_thread(data_cache): |
|
data_cache.refresh() |
|
|
|
|
|
def train_VAE(vae, encoder, decoder, data_cache, stages, batch_size): |
|
"""Train the VAE. |
|
|
|
Parameters |
|
---------- |
|
vae: keras.engine.functional.Functional |
|
The VAE. |
|
encoder: keras.engine.functional.Functional |
|
The VAE encoder. |
|
decoder: keras.engine.functional.Functional |
|
The VAE decoder. |
|
data_cache: Data_cache |
|
A Data_cache entity that provides training data. |
|
stages: Dict |
|
Defines the training stages. In each stage, the synthetic data will be refreshed and |
|
models will be stored once. |
|
|
|
Returns |
|
------- |
|
""" |
|
threshold = 1e-0 |
|
kl_weight = 100.0 |
|
|
|
def weighted_binary_cross_entropy_loss(true, pred): |
|
b_n = true * tf.math.log(tf.maximum(1e-20, pred)) + (1 - true) * tf.math.log(tf.maximum(1e-20, 1 - pred)) |
|
w = tf.maximum(threshold, true) |
|
return -tf.reduce_sum(b_n / w) / batch_size |
|
|
|
def reconstruction_loss(true, pred): |
|
reconstruction_loss = weighted_binary_cross_entropy_loss(K.flatten(true), K.flatten(pred)) |
|
return K.mean(reconstruction_loss) |
|
|
|
def kl_loss(true, pred): |
|
return pred * kl_weight |
|
|
|
for stage in stages: |
|
threshold = stage["threshold"] |
|
kl_weight = stage["kl_weight"] |
|
vae.compile(tf.keras.optimizers.Adam(learning_rate=stage["learning_rate"]), loss=[reconstruction_loss, kl_loss]) |
|
|
|
Input_all = data_cache.get_all_data() |
|
n_total = np.shape(Input_all)[0] |
|
|
|
t = threading.Thread(target=my_thread, args=(data_cache,)) |
|
t.start() |
|
history = vae.fit([Input_all, np.ones(n_total)], [Input_all, np.ones(n_total)], epochs=stage["n_epoch"], |
|
batch_size=batch_size) |
|
t.join() |
|
encoder.save(f"./models/new_trained_models/encoder.h5") |
|
decoder.save(f"./models/new_trained_models/decoder.h5") |
|
|