def block(tensor, filters, kernel_size, strides, name, rate=1, with_relu=True):
if strides == 1:
x = Conv2D(filters,
kernel_size,
strides,
padding='SAME',
use_bias=False,
dilation_rate=rate,
kernel_regularizer=l2(0.5 * 1.0),
name=name + '/conv2d',
kernel_initializer=VarianceScaling(
mode="fan_avg", distribution="uniform"))(tensor)
else:
pad_1 = (kernel_size - 1) // 2
pad_2 = (kernel_size - 1) - pad_1
x = zero_padding(tensor, pad_1, pad_2)
x = Conv2D(filters,
kernel_size,
strides,
padding='VALID',
use_bias=False,
dilation_rate=rate,
kernel_regularizer=l2(0.5 * (1.0)),
name=name + '/conv2d',
kernel_initializer=VarianceScaling(
mode="fan_avg", distribution="uniform"))(x)
x = BatchNormalization(name=name + '/batch_normalization')(x)
if with_relu:
x = ReLU()(x)
return x
def get_model(output_dims: int) -> Model:
"""Get the DQN model."""
model = Sequential()
model.add(
Conv2D(
16,
8,
strides=4,
activation="relu",
kernel_initializer=VarianceScaling(2),
input_shape=(*IMG_SIZE, STATE_FRAMES),
))
model.add(
Conv2D(
32,
4,
strides=2,
activation="relu",
kernel_initializer=VarianceScaling(2),
))
model.add(Flatten())
model.add(
Dense(256, activation="relu", kernel_initializer=VarianceScaling(2)))
model.add(Dense(output_dims, kernel_initializer=VarianceScaling(2)))
return model
def get_functional_graph(self, input_shapes, batch_size=None):
input_shape = input_shapes[0]
input = Input(shape=input_shape, name="input")
conv1 = Convolution2D(32, (8, 8),
strides=4,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_1")(input)
conv2 = Convolution2D(64, (4, 4),
strides=2,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_2")(conv1)
conv3 = Convolution2D(64, (3, 3),
strides=1,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_3")(conv2)
flat = Flatten(name='flat')(conv3)
return [input], flat
def BRModule(self, input_data, BRM_x, scale=4):
"""
A single Block Residual Module (BRM)
:param input_data: tf object
:param BRM_x: index of BRM, x sub-index in the paper
:param scale: magnifying scale factor
:return: two tf objects for upper (super resolved) and lower (back-projected) flows
"""
x1 = Conv2DTranspose(filters=64,
kernel_size=scale,
strides=scale,
padding='valid',
activation=PReLU(),
kernel_initializer=VarianceScaling(
scale=2.0,
mode="fan_in",
distribution="untruncated_normal"),
name='BRM{}_CT'.format(str(BRM_x)))(input_data)
xup = x1
for i in range(3):
xup = Conv2D(filters=64,
kernel_size=3,
padding='same',
activation=PReLU(),
kernel_initializer=VarianceScaling(
scale=2.0,
mode="fan_in",
distribution="untruncated_normal"),
name='BRM{}_C{}_u'.format(str(BRM_x),
str(i + 1)))(xup)
x2 = Conv2D(filters=64,
kernel_size=scale,
strides=scale,
padding='valid',
activation=PReLU(),
kernel_initializer=VarianceScaling(
scale=2.0,
mode="fan_in",
distribution="untruncated_normal"),
name='BRM{}_C{}_b'.format(str(BRM_x), str(1)))(x1)
x2 = Subtract(name='BRM{}_S_b'.format(str(BRM_x)))([input_data, x2])
xdn = x2
for i in range(3):
x2 = Conv2D(filters=64,
kernel_size=3,
padding='same',
activation=PReLU(),
kernel_initializer=VarianceScaling(
scale=2.0,
mode="fan_in",
distribution="untruncated_normal"),
name='BRM{}_C{}_b'.format(str(BRM_x), str(i + 2)))(x2)
xdn = Add(name='BRM{}_A_b'.format(str(BRM_x)))([xdn, x2])
return xup, xdn # xup: SR flow in upper line,,, xdn: Residual flow in bottom line
def __init__(self,
n_attention,
n_attention_hidden,
n_attention_out,
n_feat,
n_hidden,
activation="sigmoid",
concat_activity_regularizer=None,
kernel_initializer=VarianceScaling(distribution="uniform"),
kernel_regularizer='l1',
bias_initializer=Zeros(),
bias_regularizer='l1',
attention_initializer=VarianceScaling(distribution="uniform"),
attention_hidden_activation="sigmoid",
attention_output_activation="sigmoid",
attention_trainable=True,
batch_norm_kwargs={},
**kwargs):
self.n_attention = n_attention
self.n_attention_hidden = n_attention_hidden
self.n_attention_out = n_attention_out
self.n_feat = n_feat
self.n_hidden = n_hidden
self.activation = activations.get(activation)
self.concat_activity_regularizer = concat_activity_regularizer
self.kernel_initializer = kernel_initializer
self.kernel_regularizer = kernel_regularizer
self.bias_initializer = bias_initializer
self.bias_regularizer = bias_regularizer
self.attention_initializer = attention_initializer
self.attention_hidden_activation = attention_hidden_activation
self.attention_output_activation = attention_output_activation
self.attention_trainable = attention_trainable
self.batch_norm_kwargs = batch_norm_kwargs
self.attention_layers = []
for i in range(self.n_attention):
attention_layer = DenseAttention(
n_feat=self.n_feat,
n_hidden=self.n_attention_hidden,
out=self.n_attention_out,
hidden_activation=self.attention_hidden_activation,
output_activation=self.attention_output_activation,
kernel_initializer=self.attention_initializer,
trainable=self.attention_trainable)
self.attention_layers.append(attention_layer)
self.concat_layer = Concatenate(
activity_regularizer=self.concat_activity_regularizer)
#Current (v3): Use Dense layer and batch normalization
self.dense_layer = Dense(
self.n_hidden,
activation=None, #Batch normalization before activation
kernel_initializer=self.kernel_initializer,
bias_initializer=self.bias_initializer,
kernel_regularizer=self.kernel_regularizer,
bias_regularizer=self.bias_regularizer,
)
self.batch_norm_layer = BatchNormalization(**batch_norm_kwargs)
super(ConcatAttentions, self).__init__(**kwargs)
def main():
# Load the data
train_data, train_label, validation_data, validation_label, test_data, test_label, output_info = data_preparation(
)
num_features = train_data.shape[1]
print('Training data shape = {}'.format(train_data.shape))
print('Validation data shape = {}'.format(validation_data.shape))
print('Test data shape = {}'.format(test_data.shape))
print(output_info) # [(2, 'income'), (2, 'marital')]
# Set up the input layer
input_layer = Input(shape=(num_features, )) #[499,]
# Set up MMoE layer
mmoe_layers = MMoE(units=4, num_experts=8, num_tasks=2)(input_layer)
output_layers = []
# Build tower layer from MMoE layer
for index, task_layer in enumerate(mmoe_layers):
tower_layer = layers.Dense(
units=8, activation='relu',
kernel_initializer=VarianceScaling())(task_layer)
output_layer = layers.Dense(
units=output_info[index][0],
name=output_info[index][1],
activation='softmax',
kernel_initializer=VarianceScaling())(tower_layer)
output_layers.append(output_layer)
# Compile model
model = Model(inputs=[input_layer], outputs=output_layers)
# Print out model architecture summary
model.summary()
adam_optimizer = Adam()
model.compile(loss={
'income': 'binary_crossentropy',
'marital': 'binary_crossentropy'
},
optimizer=adam_optimizer,
metrics=['accuracy'])
# Train the model
model.fit(x=train_data,
y=train_label,
validation_data=(validation_data, validation_label),
callbacks=[
ROCCallback(training_data=(train_data, train_label),
validation_data=(validation_data,
validation_label),
test_data=(test_data, test_label))
],
epochs=100)
def rtvsrgan(channels=3,scale=2):
varscale = 1.
def SubpixelConv2D(scale=2,name="subpixel"):
def subpixel_shape(input_shape):
dims = [input_shape[0],
None if input_shape[1] is None else input_shape[1] * scale,
None if input_shape[2] is None else input_shape[2] * scale,
int(input_shape[3] / (scale ** 2))]
output_shape = tuple(dims)
return output_shape
def subpixel(x):
return tf.nn.depth_to_space(x, scale)
return Lambda(subpixel, output_shape=subpixel_shape, name=name)
inputs = Input(shape=(None, None, channels),name='input_1')
x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg,
kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None),
padding = "same",name='conv_1')(inputs)
x = LeakyReLU(0.2)(x)
x1 = x
x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg,
kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None),
padding = "same",name='conv_2')(x)
x2 = LeakyReLU(0.2)(x)
x = Concatenate()([x1, x2])
x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg,
kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None),
padding = "same",name='conv_3')(x)
x = LeakyReLU(0.2)(x)
x = Lambda(lambda x: x * 0.2)(x)
x = Concatenate()([x1, x2,x])
x = Conv2D(filters = scale**2*channels, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg,
kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None),
padding = "same", name='conv_4')(x)
x = SubpixelConv2D(scale=scale,name='subpixel_')(x)
x = Activation('tanh',name='tanh_')(x)
model = Model(inputs=inputs, outputs=x)
#model.summary()
return model
def __init__(self, num_filters, augment_dim=0,
time_dependent=False, activation=None, groups=None, **kwargs):
"""
Convolutional block modeling the derivative of ODE system.
# Arguments:
num_filters : int
Number of convolutional filters.
augment_dim: int
Number of augmentation channels to add. If 0 does not augment ODE.
time_dependent : bool
If True adds time as input, making ODE time dependent.
activation : string
One of 'relu' and 'softplus'
"""
dynamic = kwargs.pop('dynamic', True)
super(Conv2dODEFunc, self).__init__(**kwargs, dynamic=dynamic)
self.num_filters = num_filters
self.augment_dim = augment_dim
self.time_dependent = time_dependent
self.nfe = tf.Variable(0., trainable=False) # Number of function evaluations
self.groups = groups if groups is not None else self.num_filters
# Inits are weird to replicate PyTorch's initialization
self.kernel_init = VarianceScaling(scale=1/3., distribution='uniform')
self.bias_init = VarianceScaling(scale=1/3. * 1/9., distribution='uniform')
if time_dependent:
self.conv1 = Conv2dTime(self.num_filters,
kernel_size=(3, 3), strides=(1, 1),
padding='same',
kernel_initializer=self.kernel_init,
bias_initializer=self.bias_init)
self.conv2 = Conv2dTime(self.num_filters,
kernel_size=(3, 3), strides=(1, 1),
padding='same',
kernel_initializer=self.kernel_init,
bias_initializer=self.bias_init)
else:
self.conv1 = Conv2D(self.num_filters,
kernel_size=(3, 3), strides=(1, 1),
padding='same',
kernel_initializer=self.kernel_init,
bias_initializer=self.bias_init)
self.conv2 = Conv2D(self.num_filters,
kernel_size=(3, 3), strides=(1, 1),
padding='same',
kernel_initializer=self.kernel_init,
bias_initializer=self.bias_init)
self.norm1 = GroupNormalization(self.groups)
self.norm2 = GroupNormalization(self.groups)
self.norm3 = GroupNormalization(self.groups)
self.activation = Activation(activation)
def main():
# Load the data
train_data, train_label, validation_data, validation_label, test_data, test_label = data_preparation(
)
num_features = train_data.shape[1]
print('Training data shape = {}'.format(train_data.shape))
print('Validation data shape = {}'.format(validation_data.shape))
print('Test data shape = {}'.format(test_data.shape))
# Set up the input layer
input_layer = Input(shape=(num_features, ))
# Set up MMoE layer
mmoe_layers = MMoE(units=16, num_experts=8, num_tasks=2)(input_layer)
output_layers = []
output_info = ['y0', 'y1']
# Build tower layer from MMoE layer
for index, task_layer in enumerate(mmoe_layers):
tower_layer = Dense(units=8,
activation='relu',
kernel_initializer=VarianceScaling())(task_layer)
output_layer = Dense(units=1,
name=output_info[index],
activation='linear',
kernel_initializer=VarianceScaling())(tower_layer)
output_layers.append(output_layer)
# Compile model
model = Model(inputs=[input_layer], outputs=output_layers)
learning_rates = [1e-4, 1e-3, 1e-2]
adam_optimizer = Adam(lr=learning_rates[0])
model.compile(loss={
'y0': 'mean_squared_error',
'y1': 'mean_squared_error'
},
optimizer=adam_optimizer,
metrics=[metrics.mae])
# Print out model architecture summary
model.summary()
# Train the model
model.fit(x=train_data,
y=train_label,
validation_data=(validation_data, validation_label),
epochs=100)
def __init__(self,
n_attention,
n_attention_hidden,
n_attention_out,
n_feat,
n_hidden,
activation="sigmoid",
concat_activity_regularizer=None,
kernel_initializer=VarianceScaling(distribution="uniform"),
kernel_regularizer='l1',
bias_initializer=Zeros(),
bias_regularizer='l1',
attention_initializer=VarianceScaling(distribution="uniform"),
attention_hidden_activation="sigmoid",
attention_output_activation="sigmoid",
attention_trainable=True,
attention_feat_weight_trainable=True,
**kwargs):
self.n_attention = n_attention
self.n_attention_hidden = n_attention_hidden
self.n_attention_out = n_attention_out
self.n_feat = n_feat
self.n_hidden = n_hidden
self.activation = activations.get(activation)
self.concat_activity_regularizer = concat_activity_regularizer
self.kernel_initializer = kernel_initializer
self.kernel_regularizer = kernel_regularizer
self.bias_initializer = bias_initializer
self.bias_regularizer = bias_regularizer
self.attention_initializer = attention_initializer
self.attention_hidden_activation = attention_hidden_activation
self.attention_output_activation = attention_output_activation
self.attention_trainable = attention_trainable
self.attention_feat_weight_trainable = attention_feat_weight_trainable
self.concat_layer = Concatenate(
activity_regularizer=self.concat_activity_regularizer)
self.attention_layers = []
for i in range(self.n_attention):
attention_layer = DenseAttentionwFeatWeights(
n_feat=self.n_feat,
n_hidden=self.n_attention_hidden,
out=self.n_attention_out,
hidden_activation=self.attention_hidden_activation,
output_activation=self.attention_output_activation,
feat_weight_trainable=self.attention_feat_weight_trainable,
initializer=self.attention_initializer,
trainable=self.attention_trainable)
self.attention_layers.append(attention_layer)
super(ConcatAttentionswFeatWeights, self).__init__(**kwargs)
def wrn_block(x, subnet_id, block_offset, stride, drop_rate, channels_dict,
regularizer, se_factor):
"""creates a w.r.n block with the given parameters, the output is returned"""
conv1_name = f"Conv_{subnet_id}_{block_offset}_1"
conv2_name = f"Conv_{subnet_id}_{block_offset}_2"
x_bn_a_1 = BatchNormalization(beta_regularizer=regularizer,
gamma_regularizer=regularizer)(x)
x_bn_a_1 = Activation('relu')(x_bn_a_1)
out = Conv2D(channels_dict[conv1_name],
kernel_size=3,
padding="same",
use_bias=False,
strides=stride,
name=conv1_name,
kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'),
kernel_regularizer=regularizer)(x_bn_a_1)
if drop_rate > 0:
out = Dropout(rate=drop_rate)(out)
out = BatchNormalization(beta_regularizer=regularizer,
gamma_regularizer=regularizer)(out)
out = Activation('relu')(out)
out = Conv2D(channels_dict[conv2_name],
kernel_size=3,
padding="same",
use_bias=False,
strides=1,
name=conv2_name,
kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'),
kernel_regularizer=regularizer)(out)
if block_offset == 0: # skip_layer
skip_name = f"Skip_{subnet_id}"
x = Conv2D(channels_dict[skip_name],
kernel_size=1,
padding="same",
use_bias=False,
strides=stride,
name=skip_name,
kernel_initializer=VarianceScaling(scale=2.0,
mode='fan_out'),
kernel_regularizer=regularizer)(x_bn_a_1)
if se_factor != 0 and stride == 1:
x = se_block(x, channels_dict[conv2_name], se_factor, regularizer)
return Add()([out, x])
def make_actor(state_shape: Tuple[int, ...], action_shape: Tuple[int, ...],
scope_name: str) -> Model:
with tf.variable_scope(scope_name):
final_initializer = RandomUniform(-3e-3, 3e-3)
initializer = VarianceScaling(scale=1 / 3, mode='fan_in')
state_input = Input(shape=state_shape)
temp = Flatten()(state_input)
temp = BatchNormalization()(temp)
temp = Dense(400,
activation='relu',
kernel_initializer=initializer,
bias_initializer=initializer)(temp)
temp = BatchNormalization()(temp)
temp = Dense(300,
activation='relu',
kernel_initializer=initializer,
bias_initializer=initializer)(temp)
temp = BatchNormalization()(temp)
temp = Dense(sum(action_shape),
activation='tanh',
kernel_initializer=final_initializer,
bias_initializer=final_initializer)(temp)
output = Reshape(action_shape, name='action')(temp)
model = Model(inputs=state_input, outputs=output, name='actor')
model.compile(optimizer=Adam(1e-4), loss='mean_squared_error')
return model
def build(self, input_shape):
# input_shape: [(None, ?, 128), (None, ?, 128)]
init = VarianceScaling(scale=1.0,
mode='fan_avg',
distribution='uniform')
self.W0 = self.add_weight(name='W0',
shape=(input_shape[0][-1], 1),
initializer=init,
regularizer=l2(3e-7),
trainable=True)
self.W1 = self.add_weight(name='W1',
shape=(input_shape[1][-1], 1),
initializer=init,
regularizer=l2(3e-7),
trainable=True)
self.W2 = self.add_weight(name='W2',
shape=(1, 1, input_shape[0][-1]),
initializer=init,
regularizer=l2(3e-7),
trainable=True)
self.bias = self.add_weight(name='linear_bias',
shape=([1]),
initializer='zero',
regularizer=l2(3e-7),
trainable=True)
super(context2query_attention, self).build(input_shape)
def to_rgb(inp, style):
size = inp.shape[2]
x = Conv2DMod(3, 1, kernel_initializer=VarianceScaling(200 / size), demod=False)(
[inp, style]
)
return Lambda(upsample_to_size, output_shape=[None, im_size, im_size, None])(x)
def __init__(self,
num_filters=256,
filter_size=3,
strides=1,
weights_regularizer=None):
super().__init__()
self.layers = []
if strides > 1:
self.layers.append(ZeroPadding2D(padding=((filter_size - 1) // 2)))
self.layers.append(
Conv2D(
filters=num_filters,
kernel_size=filter_size,
strides=strides,
padding=('SAME' if strides == 1 else 'VALID'),
use_bias=False,
kernel_initializer=VarianceScaling(),
# kernel_regularizer=weights_regularizer,
))
for layer in self.layers:
logger.debug(' {}'.format(layer.name))
def __init__(
self,
n_feat,
n_hidden,
out=1,
name_idx=0,
hidden_activation="sigmoid",
output_activation="sigmoid",
feat_weight_trainable=True,
kernel_initializer=VarianceScaling(),
bias_initializer=Zeros(),
width=1., #Width of Softmin layer
**kwargs):
self.n_feat = n_feat
self.n_hidden = n_hidden
self.out = out
self.name_idx = name_idx
self.kernel_initializer = kernel_initializer
self.bias_initializer = bias_initializer
self.feat_weight_trainable = feat_weight_trainable
self.hidden_activation = activations.get(hidden_activation)
self.output_activation = activations.get(output_activation)
self.width = width
self.min_layer = Softmin(width=self.width)
super(DenseAttentionwFeatWeights, self).__init__(**kwargs)
def g_block(inp, istyle, inoise, fil, u=True):
if u:
#Custom upsampling because of clone_model issue
out = Lambda(
upsample,
output_shape=[None, inp.shape[2] * 2, inp.shape[2] * 2, None])(inp)
else:
out = Activation('linear')(inp)
rgb_style = Dense(fil,
kernel_initializer=VarianceScaling(200 /
out.shape[2]))(istyle)
style = Dense(inp.shape[-1], kernel_initializer='he_uniform')(istyle)
delta = Lambda(crop_to_fit)([inoise, out])
d = Dense(fil, kernel_initializer='zeros')(delta)
out = Conv2DMod(filters=fil,
kernel_size=3,
padding='same',
kernel_initializer='he_uniform')([out, style])
out = add([out, d])
out = LeakyReLU(0.2)(out)
style = Dense(fil, kernel_initializer='he_uniform')(istyle)
d = Dense(fil, kernel_initializer='zeros')(delta)
out = Conv2DMod(filters=fil,
kernel_size=3,
padding='same',
kernel_initializer='he_uniform')([out, style])
out = add([out, d])
out = LeakyReLU(0.2)(out)
return out, to_rgb(out, rgb_style)
def conv2d_fixed_padding(self,
inputs,
filters,
kernel_size,
strides,
data_format='channels_last'):
"""
Strided 2-D convolution with explicit padding.
The padding is consistent and is based only on `kernel_size`, not on the
dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone).
:param inputs: (Tensor) The input of size `[batch, channels, height_in, width_in]`.
:param filters: (Integer) The number of filters in the convolution.
:param kernel_size: (Integer) The size of the kernel to be used in the convolution.
:param strides: (Integer) The strides of the convolution.
:param data_format: (String) Either "channels_first" for `[batch, channels, height,
width]` or "channels_last for `[batch, height, width, channels]`.
:return: output: (tensor) A `Tensor` of shape `[batch, filters, height_out, width_out]`.
"""
if strides > 1:
inputs = self.fixed_padding(inputs,
kernel_size,
data_format=data_format)
return Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding=('SAME' if strides == 1 else 'VALID'),
use_bias=False,
kernel_initializer=VarianceScaling(),
data_format=data_format,
kernel_regularizer=tf.keras.regularizers.l2(
self.weight_decay),
bias_regularizer=tf.keras.regularizers.l2(
self.weight_decay))(inputs)
def wrn_sub_network(x, subnet_id, nb_layers, stride, drop_rate, channels_dict,
regularizer):
"""creates a w.r.n subnetwork with the given parameters, x denotes the input, the output is returned"""
for i in range(nb_layers):
conv1_name = f"Conv_{subnet_id}_{i}_1"
if conv1_name not in channels_dict or channels_dict[conv1_name] == 0:
if i == 0: # in the case the first layer was skipped, we have to use the skip 1*1 convolution as
# input for the second layer
skip_name = f"Skip_{subnet_id}"
x = BatchNormalization(beta_regularizer=regularizer,
gamma_regularizer=regularizer)(x)
x = Activation('relu')(x)
x = Conv2D(channels_dict[skip_name],
kernel_size=1,
padding="same",
use_bias=False,
strides=stride,
name=skip_name,
kernel_initializer=VarianceScaling(scale=2.0,
mode='fan_out'),
kernel_regularizer=regularizer)(x)
# otherwise there is nothing to add to the WRN
else:
x = wrn_block(x,
subnet_id,
i,
stride if i == 0 else 1,
drop_rate,
channels_dict,
regularizer=regularizer)
return x
def conv_cfg(data_format='channels_first', activation=None, scale=1.0):
return dict(
padding='same',
activation=activation,
data_format=data_format,
kernel_initializer=VarianceScaling(scale=2.0*scale) # what's VarianceScaling?
)
def __init__(self, in_state, in_actions, layers=[128, 128], reg=0.01, activation=ELU, range_high=1, range_low=-1):
self.obs = in_state
self.act = in_actions
self.init = VarianceScaling()
self.reg = l2(reg)
self.state_input = Input(shape = self.obs)
if isinstance(activation, (str, )):
x = BatchNormalization()(self.state_input)
x = Dense(layers[0], activation=activation, kernel_initializer=self.init, kernel_regularizer=self.reg)(x)
for l in layers[1:]:
x = Dense(l, activation=activation, kernel_initializer=self.init, kernel_regularizer=self.reg)(x)
else:
x = BatchNormalization()(self.state_input)
x = Dense(layers[0], activation=None, kernel_initializer = self.init, kernel_regularizer = self.reg)(x)
x = activation()(x)
for l in layers[1:]:
x = Dense(l, activation=None, kernel_initializer = self.init, kernel_regularizer = self.reg)(x)
x = activation()(x)
x = Dense(self.act, activation='tanh', use_bias=False)(x)
# move to action range
out = Lambda(lambda i: range_high * i)(x)
self.model = Model(inputs = [self.state_input], outputs=[out])
def autoencoder(dims, act='relu'):
"""
Fully connected auto-encoder model, symmetric.
Arguments:
dims: list of number of units in each layer of encoder. dims[0] is input dim, dims[-1] is units in hidden layer.
The decoder is symmetric with encoder. So number of layers of the auto-encoder is 2*len(dims)-1
act: activation, not applied to Input, Hidden and Output layers
return:
(ae_model, encoder_model), Model of autoencoder and model of encoder
"""
n_stacks = len(dims) - 1
init = VarianceScaling(scale=1. / 3., mode='fan_in', distribution='uniform')
# input
x = Input(shape=(dims[0],), name='input')
h = x
# internal layers in encoder
for i in range(n_stacks-1):
h = Dense(dims[i + 1], activation=act, kernel_initializer=init, name='encoder_%d' % i)(h)
# hidden layer
h = Dense(dims[-1], kernel_initializer=init, name='encoder_%d' % (n_stacks - 1))(h)
y = h
# internal layers in decoder
for i in range(n_stacks-1, 0, -1):
y = Dense(dims[i], activation=act, kernel_initializer=init, name='decoder_%d' % i)(y)
# output
y = Dense(dims[0], kernel_initializer=init, name='decoder_0')(y)
return Model(inputs=x, outputs=y, name='AE'), Model(inputs=x, outputs=h, name='encoder')
def Linear(in_channels, out_channels, act=None, kernel_init=None, bias_init=None):
kernel_initializer = kernel_init or VarianceScaling(1.0 / 3, 'fan_in', 'uniform')
bound = math.sqrt(1 / in_channels)
bias_initializer = bias_init or RandomUniform(-bound, bound)
return Dense(out_channels, activation=act,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)
def build_q_network(n_actions, learning_rate=0.00001, input_shape=(84, 84), history_length=4):
"""Builds a dueling DQN as a Keras model
Arguments:
n_actions: Number of possible action the agent can take
learning_rate: Learning rate
input_shape: Shape of the preprocessed frame the model sees
history_length: Number of historical frames the agent can see
Returns:
A compiled Keras model
"""
model_input = Input(shape=(input_shape[0], input_shape[1], history_length))
x = Lambda(lambda layer: layer / 255)(model_input) # normalize by 255
#print(x.shape)
AE_model = tf.keras.models.load_model("./checkpoint/AE.h5", compile=False)
AE_model.trainable = False
encoder = AE_model.layers[0]
# x = Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
# x = Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
# x = Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
#print(x.get_shape())
out_flat = Lambda(lambda f: reshape(f))(x)
#print(out_flat.get_shape())
lstm = tf.keras.layers.LSTM(512)
x = lstm(out_flat)
#print(x.get_shape())
# Split into value and advantage streams
val_stream, adv_stream = Lambda(lambda w: tf.split(w, num_or_size_splits=2, axis=1))(x) # custom splitting layer
val_stream = Flatten()(val_stream)
val = Dense(1, kernel_initializer=VarianceScaling(scale=2.))(val_stream)
adv_stream = Flatten()(adv_stream)
adv = Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.))(adv_stream)
# Combine streams into Q-Values
reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True)) # custom layer for reduce mean
q_vals = Add()([val, Subtract()([adv, reduce_mean(adv)])])
# Build model
model = Model(model_input, q_vals)
model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber())
return model
def to_image(inp, style, channels, image_size):
# Not sure if this works for rectangular images
x = Conv2DMod(channels,
1,
kernel_initializer=VarianceScaling(200 / inp.shape[2]),
demod=False)([inp, style])
return Lambda(Generator.upsample_to_size,
output_shape=[None, image_size[0], image_size[1],
None])([x, image_size])
def build(self, input_shape):
num_level_pyramid = len(input_shape[0])
self.lateral_connection_2345 = [
layers.Conv2D(self._dim, (1, 1),
padding='same',
kernel_initializer=VarianceScaling(scale=1.),
kernel_regularizer=self._kernel_regularizer)
for _ in range(num_level_pyramid)
]
self.anti_aliasing_conv = [
layers.Conv2D(self._dim, (3, 3),
padding='same',
kernel_initializer=VarianceScaling(scale=1.),
kernel_regularizer=self._kernel_regularizer)
for _ in range(num_level_pyramid)
]
super().build(input_shape)
def build_q_network(n_actions,
learning_rate=0.00001,
input_shape=(84, 84),
history_length=4):
model_input = Input(shape=(input_shape[0], input_shape[1], history_length))
x = Lambda(lambda layer: layer / 255)(model_input) # normalize by 255
x = Conv2D(32, (8, 8),
strides=4,
kernel_initializer=VarianceScaling(scale=2.),
activation='relu',
use_bias=False)(x)
x = Conv2D(64, (4, 4),
strides=2,
kernel_initializer=VarianceScaling(scale=2.),
activation='relu',
use_bias=False)(x)
x = Conv2D(64, (3, 3),
strides=1,
kernel_initializer=VarianceScaling(scale=2.),
activation='relu',
use_bias=False)(x)
# x = Conv2D(1024, (7, 7), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x)
val_stream, adv_stream = Lambda(lambda w: tf.split(w, 2, 3))(
x) # custom splitting layer
val_stream = Flatten()(val_stream)
val = Dense(1, kernel_initializer=VarianceScaling(scale=2.))(val_stream)
adv_stream = Flatten()(adv_stream)
adv = Dense(n_actions,
kernel_initializer=VarianceScaling(scale=2.))(adv_stream)
reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True))
q_vals = Add()([val, Subtract()([adv, reduce_mean(adv)])])
model = Model(model_input, q_vals)
model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber())
model.summary()
return model
def buildDQN(n_actions=4, learning_rate=0.00001, frame_height=84, frame_width=84, sequence_length=4):
input_tensor=Input(shape=(frame_height, frame_width, sequence_length), dtype=tf.float32)
input_scaled = Lambda(lambda input_unscaled: input_unscaled / 255)(input_tensor) # normalize by 255
conv1 = Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.),
activation='relu', use_bias=False,name='conv1')(input_scaled)
conv2 = Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.),
activation='relu', use_bias=False,name='conv2')(conv1)
conv3 = Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.),
activation='relu', use_bias=False,name='conv3')(conv2)
conv4 = Conv2D(1024, (7, 7), strides=1, kernel_initializer=VarianceScaling(scale=2.),
activation='relu', use_bias=False,name='conv4')(conv3)
value_stream, advantage_stream = Lambda(lambda w: tf.split(w, 2, 3))(conv4)
value_stream = Flatten(name="value_stream_flatten")(value_stream)
value = Dense(1, kernel_initializer=VarianceScaling(scale=2.),name="value_stream_dense")(value_stream)
advantage_stream = Flatten(name="advantage_stream_flatten")(advantage_stream)
advantage = Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.),name="advantage_stream_dense")(advantage_stream)
reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True),name="reduce_mean")
q_values = Add(name="q_values")([value, Subtract()([advantage, reduce_mean(advantage)])])
model = Model(input_tensor, q_values)
model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber())
return model
def get_functional_graph(self, input_shapes, batch_size=None):
input_shape = input_shapes[0]
input = Input(shape=input_shape, name="input")
conv1 = Convolution2D(32, (6, 6),
strides=4,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_1")(input)
# pool1 = MaxPool2D((2, 2))(conv1)
conv2 = Convolution2D(64, (4, 4),
strides=2,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_2")(conv1)
# pool2 = MaxPool2D((2, 2))(conv2)
conv3 = Convolution2D(64, (3, 3),
strides=1,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_3")(conv2)
# pool3 = MaxPool2D((2, 2))(conv3)
conv4 = Convolution2D(self.latent_dim, (9, 6),
strides=1,
padding='valid',
activation="relu",
kernel_initializer=VarianceScaling(scale=2),
use_bias=False,
name="conv_4")(conv3)
# pool4 = MaxPool2D((2, 2))(conv4)
flat = Flatten(name='flat')(conv4)
latent = Dense(self.latent_dim, activation="relu", name="latent")(flat)
return [input], latent
def fully_connected_dyke_dqn_agent_network(
sizes: Tuple[int, ...]) -> List[Layer]:
"""
Constructs a list of DQN agent network layers, all fully connected.
:param sizes:
:return:
"""
return [
Dense(units=size,
activation=relu,
kernel_initializer=VarianceScaling(scale=2e0)) for size in sizes
]
