def dueling_dqn(input_shape: Tuple[int], action_size: int,
learning_rate: float, noisy: bool) -> Model:
# Build the convolutional network section and flatten the output
state_input, x = build_base_cnn(input_shape, noisy)
# Determine the type of the fully collected layer
dense_layer = NoisyDense if noisy else Dense
# State value tower - V
state_value = dense_layer(256,
activation='relu',
kernel_initializer=he_uniform())(x)
state_value = dense_layer(1, kernel_initializer=he_uniform())(state_value)
state_value = Lambda(lambda s: K.expand_dims(s[:, 0], axis=-1),
output_shape=(action_size, ))(state_value)
# Action advantage tower - A
action_advantage = dense_layer(256,
activation='relu',
kernel_initializer=he_uniform())(x)
action_advantage = dense_layer(
action_size, kernel_initializer=he_uniform())(action_advantage)
action_advantage = Lambda(
lambda a: a[:, :] - K.mean(a[:, :], keepdims=True),
output_shape=(action_size, ))(action_advantage)
# Merge to state-action value function Q
state_action_value = add([state_value, action_advantage])
model = Model(inputs=state_input, outputs=state_action_value)
model.compile(loss=Huber(), optimizer=Adam(lr=learning_rate))
return model
def blstm():
model = Sequential()
# model.add(TimeDistributed(Flatten(input_shape=(x.shape[1:]))))
# samples, time steps, features中的后两者
model.add(
Bidirectional(
LSTM(250,
input_shape=(30, 513),
kernel_initializer=he_uniform(seed=50),
return_sequences=True)))
# return_sequences=true: 返回形如（samples，timesteps，output_dim）的3D张量
# 通过LSTM，把词的维度由513转变成了250
# BLSTM layer: 250 forward and 250 backward LSTM cells whose output is concatenated to form the overall output of the layer to form the overall output of the layer.
model.add(
Bidirectional(
LSTM(250,
kernel_initializer=he_uniform(seed=50),
return_sequences=True)))
model.add(
Bidirectional(
LSTM(250,
kernel_initializer=he_uniform(seed=50),
return_sequences=True)))
model.add(
TimeDistributed(
Dense(513,
activation='relu',
kernel_initializer=he_uniform(seed=50))))
# 每个time step都输出x.shape[2]长的向量
# model.add(TimeDistributed(Reshape(x.shape[0:])))
return model
def __init__(self, obs_dim, act_dim, lr):
super(ActorCritic, self).__init__()
self.obs_dim = obs_dim
self.act_dim = act_dim
self.std = 0.5
self.action_var = tf.constant(
[self.std * self.std for i in range(act_dim)])
self.cov_mat = tf.linalg.tensor_diag(self.action_var)
actor_input = keras.Input(shape=(obs_dim, ))
actor_layer = layers.Dense(
64,
activation="tanh",
kernel_initializer=initializers.he_uniform())(actor_input)
actor_layer = layers.Dense(
64,
activation="tanh",
kernel_initializer=initializers.he_uniform())(actor_layer)
actor_output = layers.Dense(act_dim, activation="tanh")(actor_layer)
self.actor = keras.Model(inputs=actor_input, outputs=actor_output)
critic_input = keras.Input(shape=(obs_dim, ))
critic_layer = layers.Dense(
64,
activation="tanh",
kernel_initializer=initializers.he_uniform())(critic_input)
critic_layer = layers.Dense(
64,
activation="tanh",
kernel_initializer=initializers.he_uniform())(critic_layer)
critic_output = layers.Dense(1)(critic_layer)
self.critic = keras.Model(inputs=critic_input, outputs=critic_output)
self.optimizer = optimizers.Adam(learning_rate=lr)
def __init__(self, obs_dim, act_dim):
super().__init__()
self.net = keras.Sequential([
layers.Dense(obs_dim + act_dim),
layers.Dense(32,
activation="tanh",
kernel_initializer=initializers.he_uniform()),
layers.Dense(32,
activation="tanh",
kernel_initializer=initializers.he_uniform()),
layers.Dense(1)
])
def get_mlp_model():
model = Sequential([
Flatten(input_shape=X_train_grayscale[0].shape, name='flatten'),
Dense(units=128,
activation=relu,
kernel_initializer=he_uniform(),
bias_initializer=he_uniform(),
name='dense_1'),
Dense(units=64,
activation=relu,
kernel_initializer=he_uniform(),
bias_initializer=he_uniform(),
name='dense_2'),
Dense(units=32,
activation=relu,
kernel_initializer=he_uniform(),
bias_initializer=he_uniform(),
name='dense_3'),
Dense(units=10,
activation=softmax,
kernel_initializer=he_uniform(),
bias_initializer=he_uniform(),
name='dense_output')
])
model.compile(
optimizer=Adam(),
loss=SparseCategoricalCrossentropy(),
metrics=['accuracy'])
return model
def build(self, hp):
###### Setup hyperparamaters
dropout = hp.Float('dropout', 0.1, 0.6)
bias_constant = hp.Float('bias', 0.01, 0.03)
optimizer = hp.Choice('optimizer', values=['adam', 'sgd', 'rmsprop'])
###### Construct model
# Initially, the network model is defined
model = Sequential()
# Add layers
model.add(
LSTM(units=self.lstm_units,
input_shape=self.input_shape,
return_sequences=True))
model.add(Dropout(dropout))
model.add(
LSTM(units=int(self.lstm_units * 0.5), return_sequences=False))
model.add(Dropout(dropout))
model.add(
Dense(features,
activation='sigmoid',
kernel_initializer=initializers.he_uniform(seed=0),
bias_initializer=initializers.Constant(bias_constant)))
# Compile model
model.compile(
optimizer=self.get_optimizer(hp, optimizer),
loss='mse',
)
return model
def __init__(self, training_config, architecture=None, name="StepCOVNetAudioModel"):
model_input = Input(shape=training_config.audio_input_shape, name="audio_input", dtype=tf.float64)
if architecture is None:
# Channel reduction
if training_config.dataset_config["NUM_CHANNELS"] > 1:
vggish_input = TimeDistributed(Conv2D(1, (1, 1), strides=(1, 1), activation='linear',
padding='same', kernel_initializer=he_uniform(42),
bias_initializer=he_uniform(42),
image_shape=model_input.shape[1:], data_format='channels_last',
name='channel_reduction')
)(model_input)
else:
vggish_input = model_input
vggish_input = BatchNormalization()(vggish_input)
vggish_model = PretrainedModels.vggish_model(input_shape=training_config.audio_input_shape,
input_tensor=vggish_input, lookback=training_config.lookback)
model_output = vggish_model(vggish_input)
# VGGish model returns feature maps for avg/max pooling. Using LSTM for additional feature extraction.
# Might be able to replace this with another method in the future
model_output = Bidirectional(
LSTM(128, return_sequences=False, kernel_initializer=glorot_uniform(42))
)(model_output)
else:
# TODO: Add support for existing audio models
raise NotImplementedError("No support yet for existing architectures")
super(AudioModel, self).__init__(model_input=model_input, model_output=model_output, name=name)
def apply_blstm(d_model=(2, 240, 2049), name='blstm', lstm_units=250):
""" Apply BLSTM to the given input_tensor.
:param input_tensor: Input of the model.
:param output_name: (Optional) name of the output, default to 'output'.
:param params: (Optional) dict of BLSTM parameters.
:returns: Output tensor.
"""
inputm = tf.keras.Input(shape=d_model, name="input")
inputt = tf.transpose(inputm, perm=[0, 2, 1, 3])
#slices = np.transpose(slices, (0, 2, 1, 3)) # 想要[batch, time, channel, freaquency]
units = lstm_units
kernel_initializer = he_uniform(seed=50)
flatten_input = TimeDistributed(Flatten())((inputt))
def create_bidirectional():
return Bidirectional(
CuDNNLSTM(units,
kernel_initializer=kernel_initializer,
return_sequences=True))
l1 = create_bidirectional()((flatten_input))
l2 = create_bidirectional()((l1))
l3 = create_bidirectional()((l2))
dense = TimeDistributed(
Dense(int(flatten_input.shape[2]),
activation='relu',
kernel_initializer=kernel_initializer))((l3))
outputt = TimeDistributed(Reshape(inputt.shape[2:]), name='output')(dense)
outputm = tf.transpose(outputt, perm=[0, 2, 1, 3])
return tf.keras.Model(inputs=inputm, outputs=outputm, name=name)
def _build_TCN_model(self) -> Model:
""" build the TCN model
# Returns:
a keras Model object
"""
previous_layer = Input(self._input_shape, name='input_layer')
input_layer = previous_layer
for i in range(self._length):
if i == self._length - 1:
filters = self._input_shape[-1]
kernel_initializer = 'zeros'
activation = 'softmax'
else:
filters = self._filters
kernel_initializer = he_uniform()
activation = 'relu'
previous_layer = Conv1D(
filters=filters,
kernel_size=self._kernel_size,
padding='causal',
# dilation_rate=2 ** i,
use_bias=self._use_bias,
kernel_initializer=kernel_initializer,
name=f'conv1d_{i+1}')(previous_layer)
previous_layer = Activation(
activation, name=f'activation_{i+1}')(previous_layer)
model = Model(inputs=input_layer, outputs=previous_layer)
return model
def _set_default_initializer(self, kwargs):
""" Sets the default initializer for convolution 2D and Seperable convolution 2D layers
to Convolutional Aware or he_uniform.
if a specific initializer has been passed in from the model plugin, then the specified
initializer will be used rather than the default.
Parameters
----------
kwargs: dict
The keyword arguments for the current layer
Returns
-------
dict
The keyword arguments for the current layer with the initializer updated to
the select default value
"""
if "kernel_initializer" in kwargs:
logger.debug("Using model specified initializer: %s",
kwargs["kernel_initializer"])
return kwargs
if self.use_convaware_init:
default = ConvolutionAware()
if self.first_run:
# Indicate the Convolutional Aware should be calculated on first run
default._init = True # pylint:disable=protected-access
else:
default = he_uniform()
if kwargs.get("kernel_initializer", None) != default:
kwargs["kernel_initializer"] = default
logger.debug("Set default kernel_initializer to: %s",
kwargs["kernel_initializer"])
return kwargs
def create_mlp_regression_model(num_units, num_layers, dropout,
l2_penalty):
"""Creates a multilayer perceptron model of num_units per layer, with num_layers.
Args:
num_units (int): The number of units in each Dense layer (or the "width").
num_layers (int): The number of densely connected layers in the model (the "depth").
dropout (float): Rate of dropout between 0.0 and 1.0 for
a dropout layer placed after every dense layer.
If set to 0.0, the layer isn't added.
l2_penalty (float): The l2 regularization factor for each
dense layer. Smaller adds less to the loss function and
affects the model less. More slows learning but can
prevent overfitting.
Returns:
model (tensorflow.keras.Sequential): The Sequential keras model.
"""
model = Sequential()
for i in range(num_layers):
model.add(
Dense(
num_units,
activation="relu",
kernel_initializer=he_uniform(),
kernel_regularizer=tf.keras.regularizers.l2(l2_penalty),
))
if dropout > 0.0:
model.add(Dropout(dropout))
model.add(Dense(1))
return model
def __init__(self):
super(ConvBNReLU, self).__init__()
self.conv = Conv2D(64,
3,
padding='same',
kernel_initializer=he_uniform())
self.bn = BatchNormalization()
self.relu = ReLU()
def build_base_cnn(input_shape: Tuple[int], noisy: bool) -> Tuple:
conv_layer = NoisyConv2D if noisy else Conv2D
input_layer = Input(shape=input_shape)
x = conv_layer(32, (8, 8),
strides=(4, 4),
activation='relu',
kernel_initializer=he_uniform())(input_layer)
x = conv_layer(64, (4, 4),
strides=(2, 2),
activation='relu',
kernel_initializer=he_uniform())(x)
x = conv_layer(64, (3, 3),
strides=(1, 1),
activation='relu',
kernel_initializer=he_uniform())(x)
x = Flatten()(x)
return input_layer, x
def deep_neural_network():
n_in = layers.Input(shape=(13, ))
n = layers.Dense(64,
activation='elu',
kernel_initializer=initializers.he_uniform())(n_in)
n = layers.Dense(128,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n = layers.Dense(128,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n = layers.Dense(256,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n = layers.Dense(128,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n = layers.Dense(128,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n = layers.Dense(64,
activation='elu',
kernel_initializer=initializers.he_uniform())(n)
n_out = layers.Dense(1, activation='linear')(n)
model = Model(inputs=n_in, outputs=n_out)
utils.plot_model(model, 'deep_neural_network.png', show_shapes=True)
model = _fit_model(model, x_train, y_train, x_validation, y_validation)
return model
def __init__(self, depth=8):
super(DnCNNRN, self).__init__()
# Initial conv + relu (same as in DnCNN)
self.conv = Conv2D(64,
3,
padding='same',
kernel_initializer=he_uniform())
self.relu = ReLU()
# Use 8 ResNet-inspired blocks (16 layers)
self.rn_layers = [BasicBlock() for i in range(depth)]
# Final conv
self.conv_final = Conv2D(1,
3,
padding='same',
kernel_initializer=he_uniform())
def __init__(self, depth=17):
super(DnCNN, self).__init__()
# Initial conv + relu
self.conv1 = Conv2D(64,
3,
padding='same',
activation='relu',
kernel_initializer=he_uniform())
# Depth - 2 cnv+bn+relu layers
self.conv_bn_relu = [ConvBNReLU() for i in range(depth - 2)]
# final conv
self.conv_final = Conv2D(1,
3,
padding='same',
kernel_initializer=he_uniform())
def conv_block(X_in, nf, k, dr):
X = Conv2D(filters=nf,
kernel_size=(k, k),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X_in)
X = Activation('relu')(X)
X = Dropout(dr)(X)
X = Conv2D(filters=nf,
kernel_size=(k, k),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = Activation('relu')(X)
X = Dropout(dr)(X)
return X
def get_kernel_initializer(self, initializer):
if initializer == 'xavier':
kernel = GlorotNormal(seed=42)
print('[INFO] -- Inizializzazione pesi: xavier\n')
elif initializer == 'he_uniform':
kernel = he_uniform(seed=42)
print('[INFO] -- Inizializzazione pesi: he_uniform\n')
else:
kernel = RandomNormal(mean=0., stddev=0.02, seed=42)
print('[INFO] -- Inizializzazione pesi: random\n')
return kernel
def __init__(self):
# One ResNet block is:
# conv1 - bn1 - relu
# conv2 - bn2
# residual connection
# relu
super(BasicBlock, self).__init__()
self.conv1 = Conv2D(64,
3,
padding='same',
kernel_initializer=he_uniform())
self.bn1 = BatchNormalization()
self.relu = ReLU()
self.conv2 = Conv2D(64,
3,
padding='same',
kernel_initializer=he_uniform())
self.bn2 = BatchNormalization()
def __init__(self, obs_dim, act_dim, lr):
super(ActorCritic, self).__init__()
self.obs_dim = obs_dim
self.act_dim = act_dim
self.actor = keras.Sequential(
[
layers.Dense(obs_dim),
layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()),
layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()),
layers.Dense(act_dim, activation="softmax")
]
)
self.critic = keras.Sequential(
[
layers.Dense(obs_dim),
layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()),
layers.Dense(32, activation="tanh", kernel_initializer=initializers.he_uniform()),
layers.Dense(1)
]
)
self.optimizer = optimizers.Adam(learning_rate=lr)
def create_mode(model_type,window_size):
input_signals = Input(shape=(window_size,5))
if(model_type == "LINEAR"):
x = Dense(1,activation = sigmoid)(input_signals)
elif (model_type == "PLOY"):
x = Dense(30,activation = sigmoid)(input_signals)
x = Dense(5,activation = sigmoid)(x)
x = Dense(1,activation = sigmoid)(x)
elif (model_type == "LSTM"):
x = LSTM(window_size,recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform())(input_signals)
elif (model_type == "BiLSTM"):
x = Bidirectional(LSTM(int(window_size/2),recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform()))(input_signals)
elif (model_type == "CNNLSTM"):
x = Conv1D(4, 256, activation='relu',input_shape=(window_size,5),padding = "same")(input_signals)
x = Conv1D(8, 128, activation='relu',padding = "same")(x)
x = Conv1D(16, 64, activation='relu',padding = "same")(x)
x = Conv1D(64, 32, activation='relu',padding = "same")(x)
x = Conv1D(128, 16, activation='relu',padding = "same")(x)
x = LSTM(window_size,recurrent_dropout = 0.2,kernel_initializer=initializers.he_uniform())(x)
else:
print("Not a supported model")
exit(0)
model = Model(input_signals, x)
return model
def create_str_to_initialiser_converter(self):
"""Creates a dictionary which converts strings to initialiser"""
str_to_initialiser_converter = {
"glorot_normal": initializers.glorot_normal,
"glorot_uniform": initializers.glorot_uniform,
"xavier_normal": initializers.glorot_normal,
"xavier_uniform": initializers.glorot_uniform,
"xavier": initializers.glorot_uniform,
"he_normal": initializers.he_normal(),
"he_uniform": initializers.he_uniform(),
"lecun_normal": initializers.lecun_normal(),
"lecun_uniform": initializers.lecun_uniform(),
"truncated_normal": initializers.TruncatedNormal,
"variance_scaling": initializers.VarianceScaling,
"default": initializers.glorot_uniform
}
return str_to_initialiser_converter
def baseline_model(self):
initializer = initializers.he_uniform()
self.clf = Sequential()
self.clf.add(Dense(128, input_dim=32, kernel_initializer=initializer))
self.clf.add(LeakyReLU())
self.clf.add(Dense(512, kernel_initializer=initializer))
self.clf.add(LeakyReLU())
self.clf.add(Dropout(0.1))
self.clf.add(Dense(256, kernel_initializer=initializer))
self.clf.add(LeakyReLU())
self.clf.add(Dropout(0.1))
self.clf.add(Dense(6,
activation='softmax')) # Final Layer using Softmax
optimizer = optimizers.Adamax(0.0008)
self.clf.compile(loss='sparse_categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return self.clf
def get_model(input_shape):
model = Sequential([
Dense(units=64,
input_shape=input_shape,
kernel_initializer=he_uniform(),
bias_initializer=ones(),
activation=relu),
Dense(units=128, activation=relu),
Dense(units=128, activation=relu),
Dense(units=128, activation=relu),
Dense(units=128, activation=relu),
Dense(units=64, activation=relu),
Dense(units=64, activation=relu),
Dense(units=64, activation=relu),
Dense(units=64, activation=relu),
Dense(units=3, activation=softmax)
])
return model
def __init__(self, learning_rate, product_features):
"""
Args:
learning_rate:
product_features:
"""
self.lr = learning_rate
self.prod_feat = product_features
self.ae_metrics = ['mse', 'cosine_similarity']
self.r_metrics = ['mse']
self.loss = 'mae'
self.EPOCHS = 500
self.BATCH_SIZE = 64
self.act_func_dict = [relu, tanh, selu, linear, LeakyReLU]
self.optimizer_dict = ['adam', 'nadam', 'rmsprop']
self.init_dict = [he_normal(1), he_uniform(1)]
self.rnn_kind_dict = ['SimpleRNN', 'LSTM', 'GRU']
self.enc_dim = None
def convolution_block(self,
x,
name,
kernel,
channels_out,
is_training,
stride=1,
max_pool=False,
activate_with_relu=True,
padding='VALID'):
with tf.variable_scope(name):
weights = tf.get_variable(
name='W',
shape=[kernel, kernel, x.shape[-1], channels_out],
dtype=tf.float32,
initializer=he_normal())
b = tf.get_variable(name='b',
shape=[channels_out],
dtype=tf.float32,
initializer=he_uniform())
x = tf.nn.conv2d(input=x,
filter=weights,
strides=[1, stride, stride, 1],
padding=padding)
x = tf.layers.batch_normalization(inputs=x,
axis=-1,
momentum=_BATCH_NORM_DECAY,
epsilon=_BATCH_NORM_EPSILON,
center=True,
scale=True,
training=is_training,
fused=True)
x += b
if activate_with_relu:
x = tf.nn.relu(x + b)
if max_pool:
x = tf.nn.max_pool(x,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding=padding)
self.layer_print(name=name, w=weights, b=b, output=x)
return x
def get_initializer(init_name='truncate_norm', init_stddev=0.05, seed=1024):
if init_name in ('truncate_norm', 'truncate_normal'):
return TruncatedNormal(stddev=init_stddev, seed=seed)
elif init_name in ('glorot_norm', 'glorot_normal', 'xavier_norm',
'xavier_normal'):
return glorot_normal(seed=seed)
elif init_name in ('he_norm', 'he_normal'):
return he_normal(seed)
elif init_name in ('trucate_uniform'):
return TruncatedNormal(stddev=init_stddev)
elif init_name in ('glorot_uniform'):
return glorot_uniform()
elif init_name in ('he_uniform'):
return he_uniform()
elif init_name in ('zero', 'zeros'):
return Zeros()
elif init_name in ('ones', 'one'):
return Ones()
else:
raise ValueError('not support {} initializer'.format(init_name))
def get_regularized_model(input_shape, dropout_rate, weight_decay):
model = Sequential([
Dense(units=64,
input_shape=input_shape,
kernel_initializer=he_uniform(),
bias_initializer=ones(),
activation=relu,
kernel_regularizer=l2(weight_decay)),
Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)),
Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)),
Dropout(rate=dropout_rate),
Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)),
Dense(units=128, activation=relu, kernel_regularizer=l2(weight_decay)),
BatchNormalization(),
Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)),
Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)),
Dropout(rate=dropout_rate),
Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)),
Dense(units=64, activation=relu, kernel_regularizer=l2(weight_decay)),
Dense(units=3, activation=softmax)
])
return model
def embed_functions(path_to_output,
path_to_models,
path_to_histories=None,
autoencoder=False,
dimension=256,
epochs=150,
batch_size=2048):
"""Function projecting functional signatures of premises into a lower dimensional space.
Arguments:
path_to_output - path to premise count functional signatures
autoencoder - if True, then autoencoder embedding will be the method of projection,
dimension - dimension of projection,
epochs - number of training epochs for the embedding model,
batch_size - batch size for the training of the embedding model,
save_model - if True, then model is saved to
path_to_current_working_directory/models/embedding_model.h5,
save_histories - if True then training history is saved to
path_to_current_working_directory/histories/embedding_model.pickle,
"""
# Get functional signatures
output_tensor = np.load(path_to_output, mmap_mode='r')
# Number of unique functions
num_fun = output_tensor.shape[-1]
# Define model parameters
if autoencoder:
output_tensor = output_tensor / np.max(output_tensor, axis=-1)
input_tensor = output_tensor
activation = 'sigmoid'
loss = 'mse'
else:
input_tensor = np.identity(num_fun)
activation = 'softmax'
loss = 'categorical_crossentropy'
# Embedding model
model_input = Input(shape=(num_fun, ), name='input')
embedding = Dense(dimension,
kernel_initializer=he_uniform(),
activation='tanh',
name='embedding')(model_input)
model_output = Dense(num_fun,
kernel_initializer=he_uniform(),
activation=activation,
name='output')(embedding)
model = Model(model_input, model_output, name='encoder_decoder')
model.summary()
# Compile model
model.compile(optimizer=RMSprop(decay=1e-8),
loss=loss,
metrics=['accuracy'])
# Train model
history = model.fit(input_tensor,
output_tensor,
epochs=epochs,
batch_size=batch_size,
shuffle=True)
# Save history
if path_to_histories is not None:
with open(
os.path.join(path_to_histories,
'embedding_model_history.pickle'),
'wb') as dictionary:
pickle.dump(history.history,
dictionary,
protocol=pickle.HIGHEST_PROTOCOL)
# Save trained model
model.save(os.path.join(path_to_models, 'embedding_model.h5'))
def ResUNet53D(input_shape=(96, 96, 125), do_rate=0.5, filt0_k12=3,
filt0_k3=8):
"""
Implementation of a 5-layer U-Net model with residual blocks for the reconstruction of power
Doppler images from sparse compound data. This model includes an initial Conv3D block that
extracts spatiotemporal features.
Residual blocks are made of Conv2D + ReLU activations.
Downsampling is implemented with MaxPooling2D.
Upsampling is implemented with Conv2DTranspose.
Dropout used on all residual blocks.
Arguments:
input_shape -- dimensions of compound dataset
do_rate -- dropout factor
filt0_k12 -- first and second kernel dimensions for first Conv3D layer
filt0_k3 -- third kernel dimension of first Conv3D layer
Returns:
model -- a Model() instance in Keras
"""
def res_block(X_in, nf, k, dr):
X = Conv2D(filters=nf,
kernel_size=(k, k),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X_in)
X = Activation('relu')(X)
X = Dropout(dr)(X)
X = Conv2D(filters=nf,
kernel_size=(k, k),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = Activation('relu')(X)
X = Dropout(dr)(X)
X_out = Add()([X, X_in])
return X_out
# Filter kernel size used for convolutional layers
filt_k = 3
# Number of filters for respective layers
F0 = 4
F1 = 32
F2 = 64
F3 = 128
F4 = 256
F5 = 512
# Input layer
X_input = Input(input_shape, dtype=tf.float32, name="input")
# Reshape input to 4-D
X = Reshape((input_shape[0], input_shape[1], input_shape[2], 1))(X_input)
# Conv3D layer
X = Conv3D(filters=F0,
kernel_size=(filt0_k12, filt0_k12, filt0_k3),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = Activation('relu')(X)
# Reshape input to 3-D
X = Reshape((input_shape[0], input_shape[1], input_shape[2] * F0))(X)
# Encoder L1
X = Conv2D(filters=F1,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F1, filt_k, do_rate)
X_skip1 = X
X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X)
# Encoder L2
X = Conv2D(filters=F2,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F2, filt_k, do_rate)
X_skip2 = X
X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X)
# Encoder L3
X = Conv2D(filters=F3,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F3, filt_k, do_rate)
X_skip3 = X
X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X)
# Encoder L4
X = Conv2D(filters=F4,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F4, filt_k, do_rate)
X_skip4 = X
X = MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')(X)
# Encoder L5
X = Conv2D(filters=F5,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F5, filt_k, do_rate)
X = Conv2DTranspose(filters=F4,
kernel_size=(filt_k, filt_k),
strides=(2, 2),
padding='same')(X)
X = Activation('relu')(X)
# Decoder L4
X = Concatenate(axis=3)([X, X_skip4])
X = Conv2D(filters=F4,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F4, filt_k, do_rate)
X = Conv2DTranspose(filters=F3,
kernel_size=(filt_k, filt_k),
strides=(2, 2),
padding='same')(X)
X = Activation('relu')(X)
# Decoder L3
X = Concatenate(axis=3)([X, X_skip3])
X = Conv2D(filters=F3,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F3, filt_k, do_rate)
X = Conv2DTranspose(filters=F2,
kernel_size=(filt_k, filt_k),
strides=(2, 2),
padding='same')(X)
X = Activation('relu')(X)
# Decoder L2
X = Concatenate(axis=3)([X, X_skip2])
X = Conv2D(filters=F2,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F2, filt_k, do_rate)
X = Conv2DTranspose(filters=F1,
kernel_size=(filt_k, filt_k),
strides=(2, 2),
padding='same')(X)
X = Activation('relu')(X)
# Decoder L1
X = Concatenate(axis=3)([X, X_skip1])
X = Conv2D(filters=F1,
kernel_size=(1, 1),
strides=1,
padding='same',
kernel_initializer=he_uniform(seed=0))(X)
X = res_block(X, F1, filt_k, do_rate)
# Output layer
X = Conv2D(filters=1, kernel_size=(1, 1), strides=1, padding='same')(X)
# Reshape output
X = Reshape((input_shape[0], input_shape[1]))(X)
# Create model
model = Model(inputs=X_input, outputs=X, name='ResUNet53D')
return model
