def build_model(self):
"""Build an actor (policy) network that maps states -> actions."""
# Set random uniform initialization with [-3e-3, 3e-3] to have all weights set around 0.
initSeed = 0
initMin = -3e-3
initMax = 3e-3
# Define input layer (states)
states = layers.Input(shape=(self.state_size, ), name='states')
# Add hidden layers according to network architecture.
for i, nUnits in enumerate(self.architecture):
net = layers.Dense(units=nUnits)(net if i > 0 else states)
if self.batchNormalization:
net = layers.BatchNormalization()(net)
if self.activation == 'leakyRelu':
net = layers.LeakyReLU(alpha=.001)(net)
else:
net = layers.Activation(activation=self.activation)(net)
if self.dropout:
net = layers.Dropout(self.dropoutRate)(net)
# Add final output layer with sigmoid activation
net = layers.Dense(
units=self.action_size,
kernel_initializer=initializers.RandomUniform(minval=initMin,
maxval=initMax,
seed=initSeed))(net)
if self.batchNormalization:
net = layers.BatchNormalization()(net)
raw_actions = layers.Activation(activation='sigmoid',
name='raw_actions')(net)
# Note that the raw actions produced by the output layer are in
# a [0.0, 1.0] range (using a sigmoid activation function).
# So, we add another layer that scales each output to the desired range
# for each action dimension. This produces a deterministic action for
# any given state vector. A noise will be added later to this action
# to produce some exploratory behavior.
# Scale [0, 1] output for each action dimension to proper range
actions = layers.Lambda(lambda x:
(x * self.action_range) + self.action_low,
name='actions')(raw_actions)
# Create Keras model
self.model = models.Model(inputs=states, outputs=actions)
plot_model(self.model, to_file='actorKeras.png', show_shapes=True)
# Define the loss function using action value (Q value) gradients
action_gradients = layers.Input(shape=(self.action_size, ))
loss = K.mean(-action_gradients * actions)
# Incorporate any additional losses here (e.g. from regularizers)
# Define optimizer and training function
optimizer = optimizers.Adam(lr=self.learningRate)
updates_op = optimizer.get_updates(params=self.model.trainable_weights,
loss=loss)
# The Q-value gradient will need to be computed using the critic model, and fed
# in while training. Hence it is specified here as part of the "inputs" used in the training function.
self.train_fn = K.function(
inputs=[self.model.input, action_gradients,
K.learning_phase()], # WHAT IS THIS?
outputs=[],
updates=updates_op)
except:
pass
#%%
import keras
from keras import layers
import numpy as np
latent_dim = 32
height = 32
width = 32
channels = 3
generator_input = keras.Input(shape=(latent_dim, ))
x = layers.Dense(128 * 16 * 16)(generator_input)
x = layers.LeakyReLU()(x)
x = layers.Reshape((16, 16, 128))(x)
x = layers.Conv2D(256, 5, padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2DTranspose(256, 4, strides=2, padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(256, 5, padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(256, 5, padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(channels, 7, activation='tanh', padding='same')(x)
def back_bone(outputs, num_class=1):
# print("input", x.shape)
# base_model = keras.applications.xception.Xception(include_top=False, input_shape=input_size, pooling='avg')(x)
# Encoder
adap_encoder_1 = EncoderAdaption(filters=128,
kernel_size=3,
dilation_rate=1)
adap_encoder_2 = EncoderAdaption(filters=128,
kernel_size=3,
dilation_rate=1)
adap_encoder_3 = EncoderAdaption(filters=128,
kernel_size=3,
dilation_rate=1)
adap_encoder_4 = EncoderAdaption(filters=64,
kernel_size=3,
dilation_rate=1)
adap_encoder_5 = EncoderAdaption(filters=32,
kernel_size=3,
dilation_rate=1)
# Decoder
decoder_conv_1 = FeatureGeneration(filters=128,
kernel_size=3,
dilation_rate=1,
blocks=3)
decoder_conv_2 = FeatureGeneration(filters=64,
kernel_size=3,
dilation_rate=1,
blocks=3)
decoder_conv_3 = FeatureGeneration(filters=32,
kernel_size=3,
dilation_rate=1,
blocks=3)
decoder_conv_4 = FeatureGeneration(filters=32,
kernel_size=3,
dilation_rate=1,
blocks=1)
aspp = ASPP_2(filters=32, kernel_size=3)
# output
conv_logits = conv(filters=num_class,
kernel_size=1,
strides=1,
use_bias=True)
# build the net
# add activations to the ourputs of the model
for i in range(len(outputs)):
# print(outputs[i].shape)
outputs[i] = layers.LeakyReLU(alpha=0.3)(outputs[i])
# (outputs[0].shape)
x = adap_encoder_1(outputs[0])
x = upsampling(x, scale=2)
x += reshape_into(adap_encoder_2(outputs[1]), x) # 512
x = decoder_conv_1(x) # 256
x = upsampling(x, scale=2)
x += reshape_into(adap_encoder_3(outputs[2]), x) # 256
x = decoder_conv_2(x) # 256
# print("x1", x.shape)
x = upsampling(x, scale=2)
x += reshape_into(adap_encoder_4(outputs[3]), x) # 128
x = decoder_conv_3(x) # 128
# print("x1", x.shape)
x = aspp(x, operation='sum') # 128
x = upsampling(x, scale=2)
x += reshape_into(adap_encoder_5(outputs[4]), x) # 64
x = decoder_conv_4(x) # 64
# print("x1", x.shape)
x = conv_logits(x)
x = upsampling(x, scale=2)
print("output", x.shape)
aux_loss = False
if aux_loss:
return x, x
else:
return x
def build_spectral_ae(input_shape=(513, 256, 1),
latent_dim=3,
n_filters=[32, 64, 128, 256, 512],
lr=0.001):
f1 = n_filters[0]
f2 = n_filters[1]
f3 = n_filters[2]
f4 = n_filters[3]
input_spect = layers.Input(input_shape)
x = layers.Conv2D(f1, (5, 5), padding='same', strides=(2, 2))(input_spect)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f1, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f1, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f2, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f2, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f2, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f3, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f3, (4, 4), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f3, (4, 4), padding='same', strides=(2, 1))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(f4, (1, 1), padding='same', strides=(2, 1))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2D(latent_dim, (1, 1), padding='same', strides=(1, 1))(x)
z = layers.BatchNormalization()(x)
input_z = layers.Input(shape=(1, 1, latent_dim))
x = layers.Conv2DTranspose(f4, (1, 1), padding='same',
strides=(1, 1))(input_z)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f3, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f3, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f3, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f2, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f2, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f2, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f1, (2, 2), padding='same', strides=(2, 2))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f1, (2, 2), padding='same', strides=(2, 1))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv2DTranspose(f1, (3, 1), padding='valid', strides=(2, 1))(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.BatchNormalization()(x)
output_spect = layers.Conv2DTranspose(1, (1, 1),
padding='same',
strides=(1, 1))(x)
encoder = Model(input_spect, z)
encoder.summary()
decoder = Model(input_z, output_spect)
decoder.summary()
outputs = decoder(encoder(input_spect))
autoencoder = Model(input_spect, outputs)
autoencoder.compile(optimizer=optimizers.Adam(lr=lr),
loss='mean_squared_error')
autoencoder.summary()
return encoder, decoder, autoencoder
def build(self):
# Exogenous data Input data input
input_layer_1 = layers.Input(shape=(self.time_window, self.exog_dim))
# input is an image of time_window x 1
# Endogenous data Input
input_layer_2 = layers.Input(shape=(self.time_window, 1))
exg_conv_layer_op_1 = layers.Conv1D(
filters=16,
kernel_size=2,
dilation_rate=[1],
strides=1,
kernel_regularizer=keras.regularizers.l2(0.01),
padding='valid')(input_layer_1)
print exg_conv_layer_op_1
exg_conv_layer_op_1 = layers.BatchNormalization()(exg_conv_layer_op_1)
exg_conv_layer_op_1 = layers.LeakyReLU()(exg_conv_layer_op_1)
end_conv_layer_op_1 = layers.Conv1D(
filters=4,
kernel_size=2,
dilation_rate=[1],
strides=1,
kernel_regularizer=keras.regularizers.l2(0.01),
padding='valid')(input_layer_2)
print end_conv_layer_op_1
concat_op = layers.Concatenate(axis=-1)(
[end_conv_layer_op_1, exg_conv_layer_op_1])
print 'Added ', concat_op
concat_op = layers.LeakyReLU()(concat_op)
print concat_op
# ---- #
# inp = input_layer_1
network_op = None
inp = concat_op
for l in range(1, self.num_layers):
d = math.pow(2, l)
network_op = self.block(inp=inp,
num_filters=4,
dilation=[d],
kernel_size=2)
print network_op
inp = network_op
network_op = layers.Conv1D(
filters=1,
kernel_size=1,
dilation_rate=[1],
strides=1,
kernel_regularizer=keras.regularizers.l2(0.01),
padding='valid')(inp)
print 'OP', network_op
network_op = layers.Flatten()(network_op)
print 'OP', network_op
model = models.Model(inputs=[input_layer_1, input_layer_2],
outputs=[network_op])
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.MSE,
metrics=[keras.metrics.mae, keras.metrics.mse])
print model.summary()
self.model = model
return
up9 = Conv2D(16, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal', name='UpConv4')(UpSampling2D(size = (2,2), name='Up4')(conv8_1))
merge9 = keras.layers.Concatenate(name='Concat4')([conv1,up9])
conv9 = Residual17(48, 16, merge9)
conv10 = Residual18(16, 2, conv9)
conv10 = Residual19(2, 1, conv10)
conv11 = Conv2D(1, 1, activation = 'sigmoid', name='Output')(conv10)
with tf.device('/device:GPU:3'):
init = initial_conv_block(inputs, weight_decay=5e-4)
#x1 = ResidualR(32, 64, init) #192x192x64
#x1 = ResidualR(64, 64, x1)
#x1 = ResidualR(64, 64, x1) #192x192x64
x1 = Conv2D(64, (3,3), padding='same', kernel_initializer='he_normal')(init)
x1 = BatchNormalization()(x1)
x1 = layers.LeakyReLU()(x1)
x1concat = keras.layers.Concatenate()([x1, conv9]) #192x192x80
x1se = squeeze_excite_block(x1concat)
x1conv1 = SeparableConv2D(80, (1,1), padding = 'same', kernel_initializer = 'he_normal')(x1se)
x1conv1 = layers.LeakyReLU()(x1conv1)
x1conv2 = Conv2D(64, (1,1), padding = 'same', kernel_initializer = 'he_normal')(x1conv1)
x1conv2 = layers.LeakyReLU()(x1conv2)
x1pool = MaxPooling2D(pool_size=(2,2))(x1conv2)
#x2 = ResidualR(64, 96, x1pool) #96x96x96
#x2 = ResidualR(96, 96, x2)
#x2 = ResidualR(96, 96, x2) #96x96x96
x2 = Conv2D(96, (3,3), padding='same', kernel_initializer='he_normal')(x1pool)
x2 = BatchNormalization()(x2)
x2 = layers.LeakyReLU()(x2)
x2concat = keras.layers.Concatenate()([x2, conv8]) #96x96x128
def add_common_layers(y):
y = layers.BatchNormalization()(y)
y = layers.LeakyReLU()(y)
# y = Dropout(0.2)(y)
return y
z = layers.multiply([z, x])
z = layers.Conv2D(128, (1, 1))(z)
z = layers.MaxPooling2D((3, 3))(z)
a_3 = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
z = layers.SpatialDropout2D(0.2)(a_3)
z = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
z = layers.SpatialDropout2D(0.2)(z)
z = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
z = layers.add([a_3, z])
z = layers.SpatialDropout2D(0.1)(z)
z = layers.BatchNormalization()(z)
z = layers.MaxPooling2D((3, 3))(z)
z = layers.Conv2D(128, (1, 1), padding='same')(z)
z = layers.ReLU()(z)
z = layers.Conv2D(64, (1, 1))(z)
z = layers.LeakyReLU(alpha=0.3)(z)
z = layers.Conv2D(32, (1, 1))(z)
z = layers.ReLU()(z)
z = layers.Flatten()(z)
# Von folgendem Layer werden die Gewichtungen erfasst
z = layers.Dense(32, kernel_regularizer=l1(0.001))(z)
z = layers.ReLU()(z)
model_output_1 = layers.Dense(1, activation='sigmoid')(z)
model = Model(input_1, model_output_1)
model.summary()
model.compile(loss=['binary_crossentropy'],
optimizer=optimizers.Nadam(lr=1e-2),
metrics=['acc'])
path = os.path.join(os.getcwd(), 'logs/')
callbacks_list = [keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
# plt.imshow(data[0])
# plt.show()
width = 256
height = 256
channels = 3
input_layer = layers.Input(name='input', shape=(height, width, channels))
# Encoder
x = layers.Conv2D(32, (5, 5),
strides=(1, 1),
padding='same',
name='conv_1',
kernel_regularizer='l2')(input_layer)
x = layers.LeakyReLU(name='leaky_1')(x)
x = layers.Conv2D(64, (3, 3),
strides=(2, 2),
padding='same',
name='conv_2',
kernel_regularizer='l2')(x)
x = layers.BatchNormalization(name='norm_1')(x)
x = layers.LeakyReLU(name='leaky_2')(x)
x = layers.Conv2D(128, (3, 3),
strides=(2, 2),
padding='same',
name='conv_3',
kernel_regularizer='l2')(x)
x = layers.BatchNormalization(name='norm_2')(x)
def build_encoder(is_discriminator=False, pooling=None, **params):
thought_vector_size = params['thought_vector_size']
pretrained_encoder = params['pretrained_encoder']
img_width = params['img_width']
cgru_size = params['csr_size']
cgru_layers = params['csr_layers']
include_top = False
LEARNABLE_CNN_LAYERS = 1
input_shape = (img_width, img_width, IMG_CHANNELS)
input_img = layers.Input(shape=input_shape)
if pretrained_encoder:
if pretrained_encoder == 'vgg16':
cnn = applications.vgg16.VGG16(input_tensor=input_img,
include_top=include_top)
elif pretrained_encoder == 'resnet50':
# Note: This is a hacked version of resnet50 with pooling removed
cnn = resnet50.ResNet50(include_top=include_top, pooling=pooling)
for layer in cnn.layers[:-LEARNABLE_CNN_LAYERS]:
layer.trainable = False
x = cnn(input_img)
else:
x = layers.Conv2D(64, (3, 3), padding='same')(input_img)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(128, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
if cgru_layers >= 1:
x = QuadCSR(cgru_size)(x)
else:
x = layers.Conv2D(cgru_size * 3 / 2, (3, 3), padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(256, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(384, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.Activation(LeakyReLU())(x)
x = layers.Conv2D(384, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
if not pooling:
x = layers.Flatten()(x)
if is_discriminator:
x = layers.Dense(1)(x)
x = layers.Activation('tanh')(x)
else:
x = layers.Dense(thought_vector_size)(x)
x = layers.BatchNormalization()(x)
return models.Model(inputs=[input_img], outputs=x)
# fig_format = 'eps'
# Loading the dataset
positions = np.loadtxt('positions.txt')
# The dataset contains the walking cycles, but we will use only the first one for training
expected_output = positions[0:40, :]
# Creating a input vector (0.008 ms is the sample time of the walking algorithm)
input = np.matrix(0.008 * np.arange(0, expected_output.shape[0])).T
# Setting the random seed of numpy's random library for reproducibility reasons
np.random.seed(0)
model = models.Sequential()
model.add(layers.Dense(75, activation=activations.linear, input_shape=(1, )))
model.add(layers.LeakyReLU(0.01))
model.add(layers.Dense(50, activation=activations.linear))
model.add(layers.LeakyReLU(0.01))
model.add(layers.Dense(20, activation=activations.linear))
model.compile(optimizer=optimizers.Adam(), loss=losses.mean_squared_error)
history = model.fit(input,
expected_output,
batch_size=len(expected_output),
epochs=num_epochs)
input_predict = np.matrix(np.arange(0, input[-1] + 0.001, 0.001)).T
# add this line to predict the output from the Neural Network
output = model.predict(input_predict)
def fpn_orientation_graph(rois,
feature_maps,
mrcnn_probs,
mrcnn_bbox,
image_meta,
pool_size,
train_bn=True):
"""Builds the computation graph of the feature pyramid network orientation
heads.
rois: [batch, num_rois, (y1, x1, y2, x2)] Proposal boxes in normalized
coordinates.
feature_maps: List of feature maps from different layers of the pyramid,
[P2, P3, P4, P5]. Each has a different resolution.
mrcnn_probs: classifier probabilities.
mrcnn_bbox: Deltas to apply to proposal boxes
image_meta: [batch, (meta data)] Image details. See compose_image_meta()
pool_size: The width of the square feature map generated from ROI Pooling.
train_bn: Boolean. Train or freeze Batch Norm layers
Returns:
r_matrices: [batch, 3, 3] rotation matrices
angles: [batch,, 3] rotation angles in Euler ZYX (radians)
"""
x = model.PyramidROIAlign(
[pool_size, pool_size],
name="roi_align_orientation")([rois, image_meta] + feature_maps)
# Two 1024 FC layers (implemented with Conv2D for consistency)
x = KL.TimeDistributed(KL.Conv2D(1024, (pool_size, pool_size),
padding="valid"),
name="mrcnn_or_conv1")(x)
x = KL.TimeDistributed(model.BatchNorm(),
name='mrcnn_or_bn1')(x, training=train_bn)
x = KL.Activation('relu')(x)
x = KL.TimeDistributed(KL.Conv2D(1024, (1, 1)), name="mrcnn_or_conv2")(x)
x = KL.TimeDistributed(model.BatchNorm(),
name='mrcnn_or_bn2')(x, training=train_bn)
x = KL.Activation('relu')(x)
x = KL.Lambda(lambda x: K.squeeze(K.squeeze(x, 3), 2),
name="pool_squeeze_or")(x)
# Add class probabilities
x = KL.Concatenate(axis=2)([x, mrcnn_probs])
# Add detected bounding box
s = K.int_shape(mrcnn_bbox)
mrcnn_bbox = KL.Reshape((s[1], s[2] * s[3]))(mrcnn_bbox)
x = KL.Concatenate(axis=2)([x, mrcnn_bbox])
x = KL.TimeDistributed(KL.Dense(1024), name='mrcnn_or_d1')(x)
x = KL.LeakyReLU(alpha=0.2)(x)
x = KL.TimeDistributed(KL.BatchNormalization(),
name='mrcnn_or_bn3')(x, training=train_bn)
x = KL.TimeDistributed(KL.Dense(1024), name='mrcnn_or_d2')(x)
x = KL.LeakyReLU(alpha=0.2)(x)
x = KL.TimeDistributed(KL.BatchNormalization(),
name='mrcnn_or_bn4')(x, training=train_bn)
x = KL.TimeDistributed(KL.Dense(6), name='mrcnn_or_d5')(x)
#s = K.int_shape(x)
#x = KL.Lambda(lambda t: tf.reshape(t, (-1, s[2])))(x)
r_matrices = KL.TimeDistributed(
KL.Lambda(lambda t: or_tools.compute_rotation_matrix_from_ortho6d(t)))(
x)
#r_matrices = KL.TimeDistributed(KL.Reshape((-1, s[1], 3, 3))(r_matrices))
angles = KL.TimeDistributed(
KL.Lambda(lambda x: or_tools.
compute_euler_angles_from_rotation_matrices(x)))(r_matrices)
#angles = KL.Reshape((-1, s[1], 3))(angles)
return r_matrices, angles
def build_generator(self):
noise_shape = (self.latent_space_size, )
model = Sequential()
model.add(
layers.Dense(8 * 8 * 1024,
use_bias=False,
input_shape=(self.latent_space_size, )))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.Reshape((8, 8, 1024)))
assert model.output_shape == (None, 8, 8, 1024
) # Note: None is the batch size
model.add(
layers.Conv2DTranspose(512,
kernel_size=self.kernel_size,
strides=(2, 2),
padding='same',
use_bias=False))
assert model.output_shape == (None, 16, 16, 512)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(
layers.Conv2DTranspose(256,
kernel_size=self.kernel_size,
strides=(2, 2),
padding='same',
use_bias=False))
assert model.output_shape == (None, 32, 32, 256)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(
layers.Conv2DTranspose(128,
kernel_size=self.kernel_size,
strides=(2, 2),
padding='same',
use_bias=False))
assert model.output_shape == (None, 64, 64, 128)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(
layers.Conv2DTranspose(3,
kernel_size=self.kernel_size,
strides=(2, 2),
padding='same',
use_bias=False,
activation='tanh'))
assert model.output_shape == (None, 128, 128, 3)
'''
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha = 0.2))
model.add(layers.Conv2DTranspose(3, kernel_size = (7,7) , strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
assert model.output_shape == (None, 256, 256, 3)'''
model.summary()
noise = Input(shape=noise_shape)
img = model(noise)
return Model(noise, img)
def make_model(input_shape, output_shape):
nn = models.Sequential()
# first, second, third layer
nn.add(layers.Conv2D(32,
(3, 3),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
input_shape=input_shape,
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(32,
(3, 3),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(32,
(3, 3),
activation="linear",
#kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.BatchNormalization())
nn.add(layers.Dropout(.4))
nn.add(layers.MaxPooling2D())
# four, five, sixth layer
nn.add(layers.Conv2D(64,
(3, 3),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(64,
(3, 3),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(64,
(3, 3),
activation="linear",
#kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.BatchNormalization())
nn.add(layers.Dropout(.4))
nn.add(layers.MaxPooling2D())
# seven, eight, nine, ten layer
nn.add(layers.Conv2D(64,
(1, 1),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(32,
(1,1),
activation="linear",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(16,
(1,1),
activation="linear",
#kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.Conv2D(16,
(3,3),
activation="linear",
#kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.LeakyReLU(0.001))
nn.add(layers.BatchNormalization())
nn.add(layers.MaxPooling2D())
nn.add(layers.Flatten())
# eleventh layer
nn.add(layers.Dense(64,
activation="relu",
kernel_regularizer=regularizers.l2(.01),
kernel_initializer="he_normal"
))
nn.add(layers.Dropout(.3))
nn.add(layers.Dense(output_shape, activation='softmax'))
nn.summary()
nn.compile(
optimizer=optimizers.Adam(lr=0.0001),
loss='categorical_crossentropy',
metrics=['accuracy']
)
return nn
def trainModel(DS, x_train, y_train, x_valid, y_valid, x_test, y_test):
'''Build and Train (pretrained) VGG16 Model'''
#Prepare Dataset for training
x_train, y_train, x_valid, y_valid, x_test, y_test = prepareDataset(
x_train, y_train, x_valid, y_valid, x_test, y_test)
# Define the parameters for VGG16 model.
IMG_HEIGHT = 48
IMG_WIDTH = 48
IMG_DEPTH = 3
BATCH_SIZE = 16
NB_EPOCHS = 100
no_of_class = noClass(DS)
print('Parameters are defined')
# Preprocessing the input
x_train = preprocess_input(x_train)
x_valid = preprocess_input(x_valid)
x_test = preprocess_input(x_test)
print('Input is preprocessed')
#Conv base
conv_base = VGG16(weights='imagenet',\
include_top=False, \
input_shape=(IMG_HEIGHT, IMG_WIDTH, IMG_DEPTH))
print('Conv Base is created')
conv_base.summary()
#Model features
train_features = conv_base.predict(np.array(x_train),
batch_size=BATCH_SIZE,
verbose=1)
val_features = conv_base.predict(np.array(x_valid),
batch_size=BATCH_SIZE,
verbose=1)
test_features = conv_base.predict(np.array(x_test),
batch_size=BATCH_SIZE,
verbose=1)
print('Featurs are created')
print("train_features shape:", train_features.shape)
print("test_features shape:", test_features.shape)
print("val_features shape:", val_features.shape)
train_features_flat = np.reshape(train_features,
(train_features.shape[0], 1 * 1 * 512))
val_features_flat = np.reshape(val_features,
(val_features.shape[0], 1 * 1 * 512))
test_features_flat = np.reshape(test_features,
(test_features.shape[0], 1 * 1 * 512))
print('Features are flattened')
# 7.0 Define the densely connected classifier followed by leakyrelu layer and finally dense layer for the number of classes
NB_TRAIN_SAMPLES = train_features_flat.shape[0]
NB_VALIDATION_SAMPLES = val_features_flat.shape[0]
model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_dim=(1 * 1 * 512)))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.Dense(no_of_class, activation='softmax'))
print('Model layers are created')
# Compile the model.
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(),
metrics=['acc'])
print('Model is compiled')
from keras import callbacks
#Define callbacks
reduce_learning = callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=2,
verbose=1,
mode='auto',
min_delta=0.0001,
cooldown=2,
min_lr=0)
early_stopping = callbacks.EarlyStopping(monitor='val_loss',
min_delta=0,
patience=7,
verbose=1,
mode='auto')
callbacks = [reduce_learning, early_stopping]
print('Call backs are defined')
print('\n\n>>>Model Trainig starts now')
# Train the the model
history = model.fit(train_features_flat,
y_train,
epochs=NB_EPOCHS,
validation_data=(val_features_flat, y_valid),
callbacks=callbacks)
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
print('')
print(f'Model training accuracy: {acc[-1]}')
print(f'Model validation accuracy: {val_loss[-1]}')
print(f'Model training loss: {acc[-1]}')
print(f'Model validation loss: {val_loss[-1]}')
test_acc, test_precision, test_recall, test_fscore, hamming_loss = modelPerformance(
model, test_features_flat, y_test)
results = {'train':[acc[-1], val_acc[-1], loss[-1], val_loss[-1]],\
'test':[test_acc, test_precision, test_recall, test_fscore, hamming_loss]}
return model, history, results
def darknet(channels,
odd_pointwise,
avg_pool_size,
cls_activ,
alpha=0.1,
in_channels=3,
in_size=(224, 224),
classes=1000):
"""
DarkNet model from 'Darknet: Open source neural networks in c,' https://github.com/pjreddie/darknet.
Parameters:
----------
channels : list of list of int
Number of output channels for each unit.
odd_pointwise : bool
Whether pointwise convolution layer is used for each odd unit.
avg_pool_size : int
Window size of the final average pooling.
cls_activ : bool
Whether classification convolution layer uses an activation.
alpha : float, default 0.1
Slope coefficient for Leaky ReLU activation.
in_channels : int, default 3
Number of input channels.
in_size : tuple of two ints, default (224, 224)
Spatial size of the expected input image.
classes : int, default 1000
Number of classification classes.
"""
input_shape = (in_channels, 224,
224) if K.image_data_format() == 'channels_first' else (
224, 224, in_channels)
input = nn.Input(shape=input_shape)
x = input
for i, channels_per_stage in enumerate(channels):
for j, out_channels in enumerate(channels_per_stage):
x = dark_convYxY(x=x,
in_channels=in_channels,
out_channels=out_channels,
alpha=alpha,
pointwise=(len(channels_per_stage) > 1)
and not (((j + 1) % 2 == 1) ^ odd_pointwise),
name="features/stage{}/unit{}".format(
i + 1, j + 1))
in_channels = out_channels
if i != len(channels) - 1:
x = nn.MaxPool2D(pool_size=2,
strides=2,
name="features/pool{}".format(i + 1))(x)
x = nn.Conv2D(filters=classes, kernel_size=1, name="output/final_conv")(x)
if cls_activ:
x = nn.LeakyReLU(alpha=alpha, name="output/final_activ")(x)
x = nn.AvgPool2D(pool_size=avg_pool_size,
strides=1,
name="output/final_pool")(x)
x = nn.Flatten()(x)
model = Model(inputs=input, outputs=x)
model.in_size = in_size
model.classes = classes
return model
def build(self):
# input is an image of time_window x 1
input_exg = layers.Input(shape=(self.time_window, 1, self.exog_dim))
input_end = layers.Input(shape=(self.time_window, 1))
op_end = input_end
op_exg = self.build_exog_cnn(input_exg)
print '---> Start of parallel layers'
# build parallel dilated layers
for l in range(self.parallel_layers):
print '--- parallel layer ', l + 1
d = math.pow(2, l)
print 'dialtion rate :', d
op_end = self.res_block(inp=op_end,
num_filters=4,
dilation=[d],
kernel_size=2)
op_exg = self.res_block(inp=op_exg,
num_filters=4,
dilation=[d],
kernel_size=2)
# build combined dilated layers
print '---> Start of combined layers'
comb_op = layers.add([op_exg, op_end])
print comb_op
for l in range(self.parallel_layers,
self.parallel_layers + self.comb_layers):
d = math.pow(2, l)
print 'layer', l + 1, 'dialtion rate :', d
comb_op = self.res_block(inp=comb_op,
num_filters=4,
dilation=[d],
kernel_size=2)
network_op = layers.Conv1D(
filters=1,
kernel_size=1,
dilation_rate=[1],
strides=1,
kernel_regularizer=keras.regularizers.l2(0.01),
padding='valid')(comb_op)
network_op = layers.LeakyReLU()(network_op)
model = models.Model(inputs=[input_exg, input_end],
outputs=[network_op])
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.MSE,
metrics=[keras.metrics.mae, keras.metrics.mse])
print model.summary()
self.model = model
return
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Define input layers
"""
它在某些方面比行动者模型简单，但是需要注意几点。首先，行动者模型旨在将状态映射到动作，
而评论者模型需要将（状态、动作）对映射到它们的 Q 值。这一点体现在了输入层中。"""
states = layers.Input(shape=(self.state_size, ), name='states')
actions = layers.Input(shape=(self.action_size, ), name='actions')
# Add hidden layer(s) for state pathway
"""It took me so, use_bias=True, bias_constraint=regularizers.l2(0.02)"""
net_states = states
net_states = layers.Dense(
units=32,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net_states)
net_states = layers.LeakyReLU(alpha=0.3)(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.Dropout(0.4)(net_states)
net_states = layers.Dense(
units=64,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net_states)
net_states = layers.LeakyReLU(alpha=0.3)(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.Dropout(0.4)(net_states)
net_actions = actions
net_actions = layers.Dense(
units=32,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net_actions)
net_actions = layers.LeakyReLU(alpha=0.3)(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.Dropout(0.4)(net_actions)
net_actions = layers.Dense(
units=64,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net_actions)
net_actions = layers.LeakyReLU(alpha=0.3)(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.Dropout(0.4)(net_actions)
# Try different layer sizes, activations, add batch normalization, regularizers, etc.
# Combine state and action pathways
"""这两个层级首先可以通过单独的“路径”（迷你子网络）处理，但是最终需要结合到一起
例如，可以通过使用 Keras 中的 Add 层级类型来实现请参阅合并层级):"""
net = layers.Add()([net_states, net_actions])
net = layers.Dense(units=256,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net)
net = layers.LeakyReLU(alpha=0.3)(net)
net = layers.BatchNormalization()(net)
net = layers.Dropout(0.4)(net)
net = layers.Dense(units=16,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(net)
net = layers.LeakyReLU(alpha=0.3)(net)
# Add more layers to the combined network if needed
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1, name='q_values')(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(lr=1e-4)
self.model.compile(optimizer=optimizer, loss='mse')
# Compute action gradients (derivative of Q values w.r.t. to actions)
"""该模型的最终输出是任何给定（状态、动作）对的 Q 值。但是，我们还需要计算此 Q 值相对于相应动作向量的梯度，以用于训练行动者模型。
这一步需要明确执行，并且需要定义一个单独的函数来访问这些梯度："""
action_gradients = K.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
def add_common_layers(y):
y = layers.BatchNormalization()(y)
y = layers.LeakyReLU()(y)
y = layers.Dropout(dropout_level)(y)
return y
import numpy as np import os import random from PIL import Image noise_dim = 16 # 噪声维度 height = 32 width = 32 channels = 3 # G net generator_input = keras.Input(shape=(noise_dim, )) out = layers.Dense(16 * 16 * 128)(generator_input) out = layers.LeakyReLU()(out) out = layers.Reshape((16, 16, 128))(out) out = layers.Conv2D(256, 5, padding='same')(out) out = layers.LeakyReLU()(out) out = layers.Conv2DTranspose(256, 4, strides=2, padding='same')(out) out = layers.LeakyReLU()(out) out = layers.Conv2D(256, 5, padding='same')(out) out = layers.LeakyReLU()(out) out = layers.Conv2D(channels, 7, activation='tanh', padding='same')(out) g_net = Model(generator_input, out) # D net
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Define input layers
states = layers.Input(shape=(self.state_size, ), name='states')
actions = layers.Input(shape=(self.action_size, ), name='actions')
# Add hidden layer(s) for state pathway
net_states = layers.Dense(units=256,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(
self.l2_reg))(states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.LeakyReLU(1e-2)(net_states)
net_states = layers.Dropout(self.dropout)(net_states)
net_states = layers.Dense(units=128,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(
self.l2_reg))(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.LeakyReLU(1e-2)(net_states)
net_states = layers.Dropout(self.dropout)(net_states)
# Add hidden layer(s) for action pathway
net_actions = layers.Dense(units=256,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(
self.l2_reg))(actions)
net_actions = layers.BatchNormalization()(net_actions)
net_states = layers.LeakyReLU(1e-2)(net_actions)
net_actions = layers.Dropout(self.dropout)(net_actions)
net_actions = layers.Dense(units=128,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(
self.l2_reg))(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_states = layers.LeakyReLU(1e-2)(net_actions)
net_actions = layers.Dropout(self.dropout)(net_actions)
# Try different layer sizes, activations, add batch normalization, regularizers, etc.
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
net = layers.LeakyReLU(1e-2)(net)
# Add more layers to the combined network if needed
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1, name='q_values')(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
plot_model(self.model, "critic.png")
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(lr=self.learning_rate)
self.model.compile(optimizer=optimizer, loss='mse')
# Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = K.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
def get_model():
model = models.Sequential()
model.add(
layers.Conv2D(8,
kernel_size,
padding='same',
input_shape=(INPUT_SHAPE_X, INPUT_SHAPE_Y, 1),
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(
layers.Conv2D(16,
kernel_size,
padding='same',
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(
layers.Conv2D(16,
kernel_size,
padding='same',
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(
layers.Conv2D(32,
kernel_size,
padding='same',
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(
layers.Conv2D(48,
kernel_size,
padding='same',
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(
layers.Conv2D(56,
kernel_size,
padding='same',
activation='relu',
kernel_initializer='he_uniform'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(
layers.Dense(128,
kernel_regularizer=regularizers.l2(regu),
kernel_initializer='he_uniform'))
model.add(layers.LeakyReLU())
model.add(layers.Dropout(0.5))
model.add(
layers.Dense(64,
kernel_regularizer=regularizers.l2(regu),
kernel_initializer='he_uniform'))
model.add(layers.LeakyReLU())
model.add(layers.Dense(OUTPUT_NUM, activation='softmax'))
model.compile(optimizer=optimizers.Adam(learning_rate=LR),
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def darknet53_model(channels,
init_block_channels,
alpha=0.1,
in_channels=3,
in_size=(224, 224),
classes=1000):
"""
DarkNet-53 model from 'YOLOv3: An Incremental Improvement,' https://arxiv.org/abs/1804.02767.
Parameters:
----------
channels : list of list of int
Number of output channels for each unit.
init_block_channels : int
Number of output channels for the initial unit.
alpha : float, default 0.1
Slope coefficient for Leaky ReLU activation.
in_channels : int, default 3
Number of input channels.
in_size : tuple of two ints, default (224, 224)
Spatial size of the expected input image.
classes : int, default 1000
Number of classification classes.
"""
input_shape = (in_channels, in_size[0], in_size[1]) if is_channels_first() else\
(in_size[0], in_size[1], in_channels)
input = nn.Input(shape=input_shape)
x = conv3x3_block(x=input,
in_channels=in_channels,
out_channels=init_block_channels,
activation=nn.LeakyReLU(
alpha=alpha, name="features/init_block/activ"),
name="features/init_block")
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
for j, out_channels in enumerate(channels_per_stage):
if j == 0:
x = conv3x3_block(
x=x,
in_channels=in_channels,
out_channels=out_channels,
strides=2,
activation=nn.LeakyReLU(
alpha=alpha,
name="features/stage{}/unit{}/active".format(
i + 1, j + 1)),
name="features/stage{}/unit{}".format(i + 1, j + 1))
else:
x = dark_unit(x=x,
in_channels=in_channels,
out_channels=out_channels,
alpha=alpha,
name="features/stage{}/unit{}".format(
i + 1, j + 1))
in_channels = out_channels
x = nn.AvgPool2D(pool_size=7, strides=1, name="features/final_pool")(x)
# x = nn.Flatten()(x)
x = flatten(x)
x = nn.Dense(units=classes, input_dim=in_channels, name="output")(x)
model = Model(inputs=input, outputs=x)
model.in_size = in_size
model.classes = classes
return model
def mk_conv_64(*, channels):
i = kr.Input((64, 64, channels), name='x0')
cc_stack = [
kr.GaussianNoise(0.025),
kr.Conv2D(10, 1),
kr.LeakyReLU(alpha=0.5),
kr.Conv2D(2),
]
h = apply_layers(i, cc_stack)
conv_stack = [
kr.GaussianNoise(0.025),
kr.Conv2D(
64,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
128,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
256,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
384,
3,
strides=2,
activation='elu',
),
]
h = apply_layers(i, conv_stack)
gp0 = kr.GlobalMaxPool2D()(h)
ap0 = kr.GlobalAveragePooling2D()(h)
conv_stack_2 = [
kr.Conv2D(
384,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
384,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
384,
3,
strides=2,
activation='elu',
),
]
conv_stack_3 = [
kr.Conv2D(
198,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
198,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
198,
3,
strides=1,
activation='elu',
),
kr.Conv2D(
198,
3,
strides=2,
activation='elu',
),
kr.Flatten(),
]
h = apply_layers(h, conv_stack_2)
h = apply_layers(h, conv_stack_3)
head = [
kr.Dense(512, activation='elu'),
kr.Dropout(0.5),
kr.Dense(256, activation='elu'),
kr.Dropout(0.5),
kr.Dense(128, activation='elu'),
kr.Dense(NL, activation='sigmoid', name='labs'),
]
cat = kr.Concatenate()([h, gp0, ap0])
y = apply_layers(cat, head)
m = krm.Model(inputs=[i], outputs=[y], name='base_conv')
m.compile(loss=f2_crossentropy,
optimizer='adam',
metrics=['binary_accuracy'])
return m
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Set random uniform initialization with [-3e-4, 3e-4] to have all weights set around 0.
# This is according to DDPG paper.
initSeed = 0
initMin = -3e-3
initMax = 3e-3
l2Lambda = 1e-2
# Define separate input layers for state and action pathways (sub-networks).
states = layers.Input(shape=(self.state_size,), name='states')
actions = layers.Input(shape=(self.action_size,), name='actions')
# Add hidden layer(s) for state pathway
for i, nUnits in enumerate(self.architecture[0]):
net_states = layers.Dense(units=nUnits, activity_regularizer=regularizers.l2(l2Lambda))(net_states if i>0 else states)
# Add batch normalization, activation and dropout.
if self.batchNormalization:
net_states = layers.BatchNormalization()(net_states)
if self.activation == 'leakyRelu':
net = layers.LeakyReLU(alpha=.001)(net)
else:
net_states = layers.Activation(activation=self.activation)(net_states)
if self.dropout:
net_states = layers.Dropout(self.dropoutRate)(net_states)
# Add hidden layer(s) for action pathway
for i, nUnits in enumerate(self.architecture[1]):
net_actions = layers.Dense(units=nUnits, activity_regularizer=regularizers.l2(l2Lambda))(net_actions if i>0 else actions)
# Add batch normalization, activation and dropout.
if self.batchNormalization:
net_actions = layers.BatchNormalization()(net_actions)
if self.activation == 'leakyRelu':
net = layers.LeakyReLU(alpha=.001)(net)
else:
net_actions = layers.Activation(activation=self.activation)(net_actions)
if self.dropout:
net_actions = layers.Dropout(self.dropoutRate)(net_actions)
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
if self.activation == 'leakyRelu':
net = layers.LeakyReLU(alpha=.001)(net)
else:
net = layers.Activation('relu')(net)
if self.dropout:
net = layers.Dropout(self.dropoutRate)(net)
# Add more layers to the combined network if needed
for nUnits in self.architecture[2]:
net = layers.Dense(units=nUnits, activity_regularizer=regularizers.l2(l2Lambda))(net)
if self.batchNormalization:
net = layers.BatchNormalization()(net)
if self.activation == 'leakyRelu':
net = layers.LeakyReLU(alpha=.001)(net)
else:
net = layers.Activation(activation=self.activation)(net)
if self.dropout:
net = layers.Dropout(self.dropoutRate)(net)
# Add final output layer to produce action values (Q values)
Q_values = layers.Dense(units=1, kernel_initializer=initializers.RandomUniform(minval=initMin, maxval=initMax, seed=initSeed), name='q_values')(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
plot_model(self.model, to_file='criticKeras.png', show_shapes=True)
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(lr=self.learningRate)
self.model.compile(optimizer=optimizer, loss='mse')
# The final output of this model is the Q-value for any given (state, action) pair.
# However, we also need to compute the gradient of this Q-value with respect
# to the corresponding action vector, needed for training the actor model.
# This step needs to be performed explicitly, and a separate function needs
# to be defined to provide access to these gradients.
# Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = K.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
X_train, X_val, Y_train, Y_val = train_test_split(train_image, train_label, test_size = 0.1, random_state=42)
train_datagen = ImageDataGenerator(rescale = 1./255.,
rotation_range = 10,
width_shift_range = 0.25,
height_shift_range = 0.25,
shear_range = 0.1,
zoom_range = 0.25,
horizontal_flip = False)
test_datagen = ImageDataGenerator(rescale = 1./255.)
model = models.Sequential()
model.add(layers.Conv2D(64, (3,3), padding = 'same', input_shape = (28,28,1)))
model.add(layers.BatchNormalization(momentum=0.5, epsilon=1e-5, gamma_initializer="uniform"))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.Conv2D(64, (3,3), padding = 'same'))
model.add(layers.BatchNormalization(momentum=0.5, epsilon=1e-5, gamma_initializer="uniform"))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.MaxPool2D(2,2))
model.add(layers.Dropout(0.2))
model.add(layers.Conv2D(128, (3,3), padding = 'same'))
model.add(layers.BatchNormalization(momentum=0.5, epsilon=1e-5, gamma_initializer="uniform"))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.Conv2D(128, (3,3), padding = 'same'))
model.add(layers.BatchNormalization(momentum=0.5, epsilon=1e-5, gamma_initializer="uniform"))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.MaxPool2D(2,2))
def call(self, inputs):
x = self.conv(inputs)
x = self.bn(x)
x = layers.LeakyReLU(alpha=0.3)(x)
return x
conv10 = Residual19(16, 1, conv10)
conv11 = Conv2D(1, 1, activation='sigmoid', name='Output')(conv10)
conv1r = _conv_bn_relu(filters=64, kernel_size=(7, 7), strides=(1, 1))(input)
block1 = _residual_block(basic_block,
filters=64,
repetitions=1,
is_first_layer=True)(conv1r)
block1concat = keras.layers.Concatenate()([block1, conv9])
block1se = squeeze_excite_block(block1concat)
block1conv1 = Conv2D(64, (1, 1),
padding='same',
kernel_initializer='he_normal')(block1se)
block1conv1 = BatchNormalization(axis=CHANNEL_AXIS)(block1conv1)
block1conv1 = layers.LeakyReLU()(block1conv1)
block1conv2 = Conv2D(64, (3, 3),
padding='same',
kernel_initializer='he_normal')(block1conv1)
block1conv2 = BatchNormalization(axis=CHANNEL_AXIS)(block1conv2)
block1conv2 = layers.LeakyReLU()(block1conv2)
block1conv3 = Conv2D(64, (1, 1),
padding='same',
kernel_initializer='he_normal')(block1conv2)
block1conv3 = BatchNormalization(axis=CHANNEL_AXIS)(block1conv3)
block1conv3 = layers.LeakyReLU()(block1conv3)
block1b = _residual_block(basic_block,
filters=64,
repetitions=1,
is_first_layer=False)(block1conv3)
def build_model(self):
#lrelu = LeakyReLU(alpha=0.1)
#Define input layers
states = layers.Input(shape=(self.state_size, ), name="states")
actions = layers.Input(shape=(self.action_size, ), name="actions")
#Add hidden layers for state pathway
net_states = layers.Dense(units=32, use_bias=False)(states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.LeakyReLU(alpha=0.1)(net_states)
net_states = layers.Dense(units=64)(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.LeakyReLU(alpha=0.1)(net_states)
#hidden layers for action
net_actions = layers.Dense(units=32)(actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.LeakyReLU(alpha=0.1)(net_actions)
net_actions = layers.Dense(units=64)(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.LeakyReLU(alpha=0.1)(net_actions)
#try different layers sizes, activations, add batch normalization, regularizers, etc.
#Combine state and action pathyways
net = layers.Add()([net_states, net_actions])
net = layers.BatchNormalization()(net)
net = layers.LeakyReLU(alpha=0.1)(net)
#Add more layers ot the combined network if needed
#Add final output layer to produce action values (Q-values)
# array?
Q_values = layers.Dense(units=1, name='q_values')(net)
#Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
#Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(lr=self.critic_local_lr)
self.model.compile(optimizer=optimizer, loss='mse')
self.model.summary()
#Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = K.gradients(Q_values, actions) #dQ/dA
"""Q_values Tensor("q_values/BiasAdd:0", shape=(?, 1), dtype=float32)
actions Tensor("actions:0", shape=(?, 1), dtype=float32)"""
print("Q_values", Q_values, "actions", actions) #
print("action_gradients", action_gradients) #[None]
print("action_gradients type", type(action_gradients)) #list
#print("self.model.input", self.model.input) #states and actions
"""self.get_action_gradients can be called by agent's critic_local in def learn, action-grads used by action grads
K.function runs the graph to get the Q-value necessary to calculate action_gradients which is the output
call:
action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), \
(-1, self.action_size))
"""
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
print("self.get_action_gradients", self.get_action_gradients)
# Define model
logger.info('Constructing model...')
input_shape = 1, MEL_BANDS, SEGMENT_LENGTH # , SEGMENT_LENGTH
# model = keras.models.Sequential()
print("pre")
model = keras.models.Sequential([
layers.Input(shape=input_shape),
layers.Reshape((100, 80, 1), input_shape=input_shape),
layers.Conv2D(80, (3, 3),
kernel_regularizer=L2(0.001),
kernel_initializer='he_uniform',
activation="relu"),
layers.LeakyReLU(),
layers.MaxPool2D((3, 3), (3, 3)),
layers.Conv2D(160, (3, 3),
kernel_regularizer=L2(0.001),
kernel_initializer='he_uniform',
activation="relu"),
layers.LeakyReLU(),
layers.MaxPool2D((3, 3), (3, 3)),
layers.Conv2D(240, (3, 3),
kernel_regularizer=L2(0.001),
kernel_initializer='he_uniform',
activation="relu"),
layers.LeakyReLU(),
layers.MaxPool2D((3, 3), (3, 3)),
layers.Flatten(),
layers.Dropout(rate=0.5),
