def __init__(self,
out_channels,
cnn_kernel_size=3,
pooling_kernel_size=[2, 1]):
super(CNNBlock, self).__init__()
k_initializer = tf.keras.initializers.truncated_normal()
b_initializer = tf.keras.initializers.zeros()
self.conv1 = layers.Conv2D(filters=out_channels,
kernel_size=cnn_kernel_size,
kernel_initializer=k_initializer,
bias_initializer=b_initializer,
kernel_regularizer=regularizers.L2(l2=1e-5),
data_format='channels_last',
activation='relu',
padding='same')
self.bn = layers.BatchNormalization(
epsilon=1e-5,
scale=True,
trainable=True,
)
self.conv2 = layers.Conv2D(filters=out_channels,
kernel_size=cnn_kernel_size,
kernel_regularizer=regularizers.L2(l2=1e-5),
kernel_initializer=k_initializer,
bias_initializer=b_initializer,
data_format='channels_last',
activation='relu',
padding='same')
self.pooling = layers.MaxPool2D(pool_size=pooling_kernel_size,
strides=[2, 1],
padding='same')
def second():
X_input = tf.keras.Input((100, 100, 3))
X = X_input
X = inception_one(X)
X = inception_one(X)
X = inception_three(X)
X = inception_two(X)
X = tf.keras.layers.BatchNormalization()(X)
X = tf.keras.layers.Flatten()(X)
print(X.shape)
X_res = tf.keras.layers.Dense(50, activation='relu')(X)
X = tf.keras.layers.Dropout(rate=0.4, noise_shape=(X.shape[1], ))(X)
X = tf.keras.layers.Dense(512,
activation='relu',
kernel_regularizer=regularizers.L2(0.001))(X)
X = tf.keras.layers.Dropout(rate=0.3, noise_shape=(512, ))(X)
X = tf.keras.layers.BatchNormalization()(X)
X = tf.keras.layers.Dense(50, activation=None)(X)
X = tf.keras.layers.Dropout(0.4, noise_shape=(50, ))(X)
X = tf.keras.layers.ReLU()(tf.add(X, X_res))
X = tf.keras.layers.Dense(25,
activation='relu',
kernel_regularizer=regularizers.L2(0.001))(X)
X = tf.keras.layers.Dropout(rate=0.3, noise_shape=(25, ))(X)
X = tf.keras.layers.Dense(numClasses, activation='softmax')(X)
return tf.keras.Model(inputs=X_input, outputs=X)
def create_after_emb(self,
reshape1,
conv_channels=32,
emb_height=100,
activation="relu",
L2_lambda=0.02,
conv_sizes=[2, 3, 5, 7]):
conv3d = layers.Conv3D(1, (4, 4, 10),
padding="same",
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda),
data_format="channels_last")(reshape1)
pooling3d = layers.MaxPooling3D(pool_size=(1, 1, emb_height),
data_format="channels_last")(conv3d)
rs = layers.Reshape((self.crop, self.img_x, 1))(pooling3d)
# parallel piece
convolutions = [
layers.Conv2D(conv_channels, (conv_size, conv_size),
padding="same",
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda),
data_format="channels_last")(rs)
for conv_size in conv_sizes
]
pools = [
layers.MaxPooling2D(pool_size=4,
padding="same",
data_format="channels_last")(conv)
for conv in convolutions
]
connect = layers.concatenate(pools, axis=3)
norm0 = layers.LayerNormalization(axis=-1)(connect)
drop1 = layers.Dropout(0.5)(norm0)
big_conv_channels = 1
big_convolution = layers.Conv2D(
big_conv_channels, (4, emb_height),
padding="same",
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda),
data_format="channels_last")(drop1) # 100, 100, 4
flatten = layers.Flatten()(big_convolution)
norm1 = layers.LayerNormalization(axis=-1)(flatten)
drop2 = layers.Dropout(0.5)(norm1)
dense = layers.Dense(self.output_size)(drop2)
return dense
def build(self, input_shape):
num_origin_capsule = input_shape[-3]
if self.num_capsule and num_origin_capsule % self.num_capsule == 0:
self.rate = int(
num_origin_capsule /
self.num_capsule) if self.rate is None else self.rate
elif self.rate and num_origin_capsule % self.rate == 0:
self.num_capsule = int(
num_origin_capsule /
self.rate) if self.num_capsule is None else self.num_capsule
else:
raise ValueError(
"[ERROR]When check 'num_origin_capsule' and 'num_capsule', recommend select one of them."
)
if num_origin_capsule != self.num_capsule * self.rate:
raise ValueError(
"[ERROR]When check 'num_origin_capsule == self.num_capsule * self.rate'."
)
self.W = self.add_weight("W",
shape=[self.rate, *self.matrix_shape],
dtype=tf.float32,
initializer=self.kernel_initializer,
regularizer=regularizers.L2(self.regularize))
self.reshape = layers.Reshape(
(self.num_capsule, self.rate, *self.matrix_shape))
def model_definition(input_shape):
model = models.Sequential()
model.add(layers.Dense(
units=10,
input_shape=(input_shape,),
use_bias=True,
#activation=activations.relu,
activity_regularizer=regularizers.L2(0.0)))
# model.add(layers.Dense(
# units=3,
# activity_regularizer=regularizers.L2(0.000),
# #activation=activations.relu,
# use_bias=True))
model.add(layers.Dense(
units=1,
activity_regularizer=regularizers.L1(0.0),
#activation=activations.sigmoid,
use_bias=True))
model.compile(
optimizer=optimizers.SGD(0.001),
loss=losses.MSE,
metrics=['acc'])
return model
def train_gru(self, params):
position_train, dct_train, y_train = self.preprocess_training_data()
num_examples = len(position_train)
position_len = len(position_train[0][0])
dct_len = len(dct_train[0])
# Padding
print("Padding Training Data (for variable-length input)")
position_train_pad, max_seq_len, special_value = self.pad(
position_train)
print("Building Model")
position_input = keras.Input(shape=(None, position_len))
gru = layers.Masking(mask_value=special_value)(position_input)
gru = layers.BatchNormalization()(gru)
gru = layers.GRU(
128,
kernel_regularizer=regularizers.L2(l2=params['kernel_l2']),
bias_regularizer=regularizers.L2(params['bias_l2']))(gru)
gru = keras.Model(inputs=position_input, outputs=gru)
dct_input = keras.Input(shape=(dct_len, ))
dct_normalized = layers.BatchNormalization()(dct_input)
dct = keras.Model(inputs=dct_input, outputs=dct_normalized)
combined = layers.concatenate([gru.output, dct.output])
prediction = layers.Dense(self.num_categories,
activation='sigmoid')(combined)
model = keras.Model(inputs=[gru.input, dct.input], outputs=prediction)
model.summary()
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=params['lr'],
decay_steps=100,
decay_rate=params['decay_rate'])
optimizer = keras.optimizers.Adam(learning_rate=lr_schedule)
model.compile(loss=params['loss_function'], optimizer=optimizer)
print("Fitting Model")
model.fit(x=[position_train_pad, dct_train],
y=y_train,
epochs=500,
batch_size=num_examples)
self.model = model
print("Model Successfully Fit")
def create_after_emb(self,
reshape1,
conv_channels=2,
emb_height=100,
activation="relu",
L2_lambda=0.02,
conv_sizes=[2, 4, 16]):
# parallel piece
convolutions = [
layers.Conv2D(conv_channels, (conv_size, emb_height),
name="conv2d_size_{}".format(conv_size),
padding="same",
activation=activation,
kernel_initializer=initializers.HeNormal(),
kernel_regularizer=regularizers.L2(L2_lambda),
input_shape=(1, self.crop, emb_height),
data_format="channels_last")(reshape1)
for conv_size in conv_sizes
]
pools = [
layers.MaxPooling2D(pool_size=(self.crop, 1),
data_format="channels_last")(conv)
for conv in convolutions
]
connect = layers.concatenate(pools, axis=3)
norm0 = layers.LayerNormalization(axis=-1)(connect)
drop1 = layers.Dropout(0.5)(norm0)
flatten = layers.Flatten()(drop1)
big_convolution = layers.Dense(
500,
activation=activation,
kernel_initializer=initializers.HeNormal(),
kernel_regularizer=regularizers.L2(L2_lambda))(
flatten) # 100, 100, 4
# reshape2 = layers.Reshape((-1, emb_height * big_conv_channels))(big_convolution)
norm1 = layers.LayerNormalization(axis=-1)(big_convolution)
drop2 = layers.Dropout(0.5)(norm1)
dense = layers.Dense(self.output_size,
activation=activation,
kernel_initializer=initializers.HeNormal())(drop2)
return dense
def create_model(self,
activation: str = "linear",
L2_lambda: float = 0.02,
pool_1_size: int = 4,
pool_2_size: int = 4,
conv_1_size: int = 16,
conv_2_size: int = 4,
dense_1: int = 64):
model_core = keras.Sequential()
model_core.add(layers.Reshape((-1, 1)))
model_core.add(
layers.Conv1D(64,
conv_1_size,
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda)))
model_core.add(layers.LayerNormalization(axis=1))
model_core.add(layers.MaxPooling1D(pool_size=pool_1_size))
model_core.add(
layers.Conv1D(32,
conv_2_size,
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda)))
model_core.add(layers.LayerNormalization(axis=1))
model_core.add(layers.MaxPooling1D(pool_size=pool_2_size))
model_core.add(layers.Flatten())
model_core.add(layers.Dropout(0.5))
model_core.add(
layers.Dense(dense_1,
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda)))
model_core.add(layers.LayerNormalization(axis=1))
model_core.add(layers.Dropout(0.5))
model_core.add(
layers.Dense(self.output_size,
activation=activation,
kernel_regularizer=regularizers.L2(L2_lambda)))
model_core.add(layers.LayerNormalization(axis=1))
return model_core
def fitModel(pd_data, cfg):
xtrain, ytrain, xval, yval = getData(pd_data, verbose=0)
nnodes_h1, dropout_h1, nnodes_h2, dropout_h2, merge, nbatch, opt, nepoch, lr, l2_lam = cfg
nframe = xtrain.shape[1]
isize = xtrain.shape[2]
model = Sequential()
model.add(
Bidirectional(LSTM(nnodes_h1,
return_sequences=True,
dropout=dropout_h1,
kernel_regularizer=regularizers.L2(l2_lam)),
merge_mode=merge,
input_shape=(nframe, isize)))
model.add(
Bidirectional(LSTM(nnodes_h2,
return_sequences=False,
dropout=dropout_h2,
kernel_regularizer=regularizers.L2(l2_lam)),
merge_mode=merge))
# model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# chose optimiser
if opt == 'adam':
opt = optimizers.Adam(learning_rate=lr)
# elif opt == 'sgd':
# opt= optimizers.SGD(learning_rate = lr)
else:
opt = optimizers.RMSprop(learning_rate=lr)
model.compile(loss='binary_crossentropy',
optimizer=opt,
metrics=['accuracy'])
history = model.fit(xtrain,
ytrain,
batch_size=nbatch,
validation_data=(xval, yval),
epochs=nepoch,
verbose=0)
loss, acc = model.evaluate(xval, yval, verbose=0)
clear_session()
return loss, acc, history.history
def build(self, input_shape):
i, k = input_shape[-2], input_shape[-1]
j, l = self.num_caps, self.caps_length
if self.caps_length:
weight_shape = [i, j, k, l]
else:
weight_shape = [i, j, k]
self.W = self.add_weight(shape=weight_shape,
initializer=self.kernel_initializer,
name='W',
regularizer=regularizers.L2(1e-4))
def inception_one(X_input):
X = X_input
sequence_six_one = tf.keras.Sequential([
tf.keras.layers.Conv2D(3,
1,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(32,
5,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D()
])
sequence_six_two = tf.keras.Sequential([
tf.keras.layers.Conv2D(4,
1,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(32,
5,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D()
])
sequence_six_three = tf.keras.Sequential([
tf.keras.layers.Conv2D(2, 1, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64, 5, kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D()
])
X = tf.concat(
[sequence_six_one(X),
sequence_six_two(X),
sequence_six_three(X)], -1)
return X
def model_compile(loss_fun, x_shape_1):
model = models.Sequential()
model.add(
layers.Dense(units=100,
input_shape=(x_shape_1, ),
use_bias=True,
activation=activations.sigmoid,
activity_regularizer=regularizers.L2(0.05)))
model.add(
layers.Dense(units=10,
activity_regularizer=regularizers.L2(0.05),
use_bias=True))
model.compile(
optimizer=optimizers.SGD(0.003),
loss=loss_fun, #losses.CategoricalCrossentropy( from_logits=True),
metrics=['acc'])
return model
def inception_two(X_input):
X = X_input
sequence_one = tf.keras.Sequential([
tf.keras.layers.Conv2D(3, 1, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(32, 3, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(32, 5, kernel_regularizer=regularizers.L2())
])
sequence_two = tf.keras.Sequential([
tf.keras.layers.Conv2D(2, 1, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64, 5, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64, 3, kernel_regularizer=regularizers.L2())
])
sequence_three = tf.keras.Sequential([
tf.keras.layers.Conv2D(1, 1, kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64, 3, kernel_regularizer=regularizers.L2()),
tf.keras.layers.ZeroPadding2D(),
tf.keras.layers.Conv2D(32, 7, kernel_regularizer=regularizers.L2())
])
return tf.concat([sequence_two(X), sequence_three(X), sequence_one(X)], -1)
def train_fcnn(self, params=fcnn_default_params_discrete):
X_train, y_train = self.preprocess_training_data()
input_layer_size = len(X_train[0])
model = models.Sequential()
model.add(keras.Input(shape=(input_layer_size, )))
model.add(layers.BatchNormalization())
model.add(
layers.Dense(
3000,
activation='relu',
kernel_regularizer=regularizers.L2(l2=params['kernel_l2']),
bias_regularizer=regularizers.L2(l2=params['bias_l2'])))
model.add(layers.BatchNormalization())
model.add(
layers.Dense(
3000,
activation='relu',
kernel_regularizer=regularizers.L2(l2=params['kernel_l2']),
bias_regularizer=regularizers.L2(l2=params['bias_l2'])))
model.add(layers.Dense(self.num_categories, activation='sigmoid'))
model.summary()
optimizer = keras.optimizers.Adam(lr=params['lr'])
model.compile(loss=params['loss_function'], optimizer=optimizer)
print("Fitting Model")
model.fit(X_train, y_train, epochs=100, batch_size=len(X_train))
keras.backend.set_value(model.optimizer.learning_rate,
params['lr'] / 2)
model.fit(X_train, y_train, epochs=100, batch_size=len(X_train))
keras.backend.set_value(model.optimizer.learning_rate,
params['lr'] / 4)
model.fit(X_train, y_train, epochs=500, batch_size=len(X_train))
self.model = model
print("Model Successfully Fit")
def __init__(self,
out_length,
rate=2,
strides=2,
regularize=1e-5,
**kwargs):
super(CondenseTiny, self).__init__(**kwargs)
self.sparse_extraction = layers.Conv1D(
out_length,
rate,
strides=strides,
use_bias=False,
kernel_regularizer=regularizers.L2(regularize))
self.normal = layers.LayerNormalization()
self.activation = layers.ELU()
def model_definition_dense(num_classes, input_shape=784):
model = Sequential()
model.add(
Dense(100,
activation='relu',
input_shape=(input_shape, ),
activity_regularizer=regularizers.L2(0.1)))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=0.001),
metrics=['acc'])
model.summary()
return model
def __init__(self,
num_capsule: int,
matrix_shape=(4, 4),
kernel_initializer='glorot_uniform',
regularize=1e-4):
super(GlobalMatrix, self).__init__()
if len(matrix_shape) != 2:
raise ValueError(
"[ERROR]Parameter 'matrix_shape' should be a tuple with 2 element, for example (4, 4)"
)
self.W = self.add_weight("W",
shape=[num_capsule, *matrix_shape],
dtype=tf.float32,
initializer=kernel_initializer,
regularizer=regularizers.L2(regularize))
def _construct_network(self,
hu_ns,
out_units,
act_func='relu',
activity_regularizer=regularizers.L2(.05),
noise=0,
**kwargs):
ls = []
for n in hu_ns:
ls.append(layers.Dense(n, activation=act_func, **kwargs))
if noise > 0:
ls.append(layers.GaussianNoise(noise))
out_units_n = out_units**len(self.recon_inds)
ls.append(layers.Dense(out_units_n))
model = keras.Sequential(ls)
return model
def __init__(self,
output_num,
kernel_size=1,
activation_fn='relu',
bn_flag=True,
name=None):
super(ConvBlock, self).__init__()
k_initializer = tf.keras.initializers.truncated_normal()
b_initializer = tf.keras.initializers.zeros()
self.conv = layers.Conv2D(output_num,
kernel_size,
activation=activation_fn,
kernel_initializer=k_initializer,
kernel_regularizer=regularizers.L2(l2=1e-5),
bias_initializer=b_initializer,
padding='same',
trainable=True,
name=name)
self.bn = layers.BatchNormalization(epsilon=1e-5, scale=True)
self.bn_flag = bn_flag
def __init__(self,
filters: int,
kernel_size: int,
pooling_size: int,
dropout_rate: float = 0.1,
batch_normalization: bool = True,
spatial: bool = True,
l2_regularization: float = 0.0):
super().__init__()
leaky_relu = LeakyReLU(alpha=0.01)
if l2_regularization != 0:
kernel_regularizer = regularizers.L2(l2=l2_regularization)
else:
kernel_regularizer = None
self.convolution = Conv1D(filters,
kernel_size=kernel_size,
activation=leaky_relu,
kernel_regularizer=kernel_regularizer)
if dropout_rate > 0:
if spatial:
self.dropout = SpatialDropout1D(dropout_rate)
else:
self.dropout = Dropout(dropout_rate)
else:
self.dropout = None
if pooling_size > 1:
self.max_pooling = MaxPooling1D(pool_size=pooling_size)
else:
self.max_pooling = None
if batch_normalization:
self.batch_normalization = BatchNormalization(scale=False)
if not spatial:
self.batch_normalization_input_reshape = Reshape([-1])
self.batch_normalization_output_reshape = Reshape(
[-1, filters])
else:
self.batch_normalization_input_reshape = None
self.batch_normalization_output_reshape = None
else:
self.batch_normalization = None
def inception_three(X_input):
X = X_input
sequence_six_one = tf.keras.Sequential([
tf.keras.layers.Conv2D(3,
1,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(32,
5,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D(
pool_size=(5, 5),
strides=(1, 1),
)
])
sequence_six_two = tf.keras.Sequential([
tf.keras.layers.Conv2D(4,
1,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64,
3,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D(pool_size=(7, 7), strides=(1, 1))
])
sequence_six_three = tf.keras.Sequential([
tf.keras.layers.Conv2D(1,
1,
padding='valid',
kernel_regularizer=regularizers.L2()),
tf.keras.layers.Conv2D(64, 7, kernel_regularizer=regularizers.L2()),
tf.keras.layers.MaxPooling2D(pool_size=(3, 3), strides=(1, 1))
])
X = tf.concat(
[sequence_six_one(X),
sequence_six_two(X),
sequence_six_three(X)], -1)
return X
def _build_model(self):
# ------------------ build evaluate_net ------------------
# shared part
shared_model = models.Sequential()
# pre-process block
shared_model.add(
Conv3D(32, (3, 3, 3),
strides=(1, 1, 1),
input_shape=self.input_shape,
name='conv1'))
shared_model.add(BatchNormalization(name='b1'))
shared_model.add(Activation('relu'))
shared_model.add(
MaxPooling3D(pool_size=(2, 2, 1),
strides=1,
padding="VALID",
name='p1'))
# resnet blocks
shared_model.add(self.build_resblock(32, 2, name='Resnet_1'))
shared_model.add(self.build_resblock(64, 2, name='Resnet_2', stride=2))
shared_model.add(self.build_resblock(64, 2, name='Resnet_3', stride=2))
shared_model.add(self.build_resblock(128, 2, name='Resnet_4',
stride=2))
# shared_model.summary()
self.shared_model = shared_model
# action model
act_model = models.Sequential()
# add shared block
act_model.add(shared_model)
# fully connected block
act_model.add(GlobalAveragePooling3D())
act_model.add(
Dense(self.act_dim,
name="d1",
kernel_regularizer=regularizers.L2(0.001)))
# act_model.summary()
self.act_model = act_model
# move model
move_model = models.Sequential()
# add shared block
move_model.add(shared_model)
# fully connected block
move_model.add(GlobalAveragePooling3D())
move_model.add(
Dense(4, name="d1", kernel_regularizer=regularizers.L2(0.001)))
# move_model.summary()
self.move_model = move_model
# ------------------ build target_model ------------------
shared_target_model = models.Sequential()
# pre-process block
shared_target_model.add(
Conv3D(32, (3, 3, 3),
strides=(1, 1, 1),
input_shape=self.input_shape,
name='conv1'))
shared_target_model.add(BatchNormalization(name='b1'))
shared_target_model.add(Activation('relu'))
shared_target_model.add(
MaxPooling3D(pool_size=(2, 2, 1),
strides=1,
padding="VALID",
name='p1'))
# resnet blocks
shared_target_model.add(self.build_resblock(32, 2, name='Resnet_1'))
shared_target_model.add(
self.build_resblock(64, 2, name='Resnet_2', stride=2))
shared_target_model.add(
self.build_resblock(64, 2, name='Resnet_3', stride=2))
shared_target_model.add(
self.build_resblock(128, 2, name='Resnet_4', stride=2))
self.shared_target_model = shared_target_model
# action model
act_target_model = models.Sequential()
# add shared block
act_target_model.add(shared_target_model)
# fully connected block
act_target_model.add(GlobalAveragePooling3D())
act_target_model.add(
Dense(self.act_dim,
name="d1",
kernel_regularizer=regularizers.L2(0.001)))
# act_target_model.summary()
self.act_target_model = act_target_model
# move model
move_target_model = models.Sequential()
# add shared block
move_target_model.add(shared_target_model)
# fully connected block
move_target_model.add(GlobalAveragePooling3D())
move_target_model.add(
Dense(4, name="d1", kernel_regularizer=regularizers.L2(0.001)))
# move_target_model.summary()
self.move_target_model = move_target_model
def _build_model(self):
# ------------------ build evaluate_net ------------------
self.shared_model = models.Sequential()
self.private_act_model = models.Sequential()
self.private_move_model = models.Sequential()
# shared part
# pre-process block
# self.shared_model.add(Conv3D(64, (2,3,3),strides=(1,2,2), input_shape=self.input_shape, name='conv1'))
# # self.shared_model.add(BatchNormalization(name='b1'))
# self.shared_model.add(Activation('relu'))
# self.shared_model.add(MaxPooling3D(pool_size=(2,2,2), strides=1, padding="VALID", name='p1'))
# # resnet blocks
# self.shared_model.add(self.build_resblock(64, 2, name='Resnet_1'))
# self.shared_model.add(self.build_resblock(80, 2, name='Resnet_2', stride=2))
# self.shared_model.add(self.build_resblock(128, 2, name='Resnet_3', stride=2))
# output layer for action model
self.private_act_model.add(
Conv3D(64, (2, 3, 3),
strides=(1, 2, 2),
input_shape=self.input_shape,
name='conv1'))
# self.private_act_model.add(BatchNormalization(name='b1'))
self.private_act_model.add(Activation('relu'))
self.private_act_model.add(
MaxPooling3D(pool_size=(2, 2, 2),
strides=1,
padding="VALID",
name='p1'))
# resnet blocks
self.private_act_model.add(self.build_resblock(64, 2, name='Resnet_1'))
self.private_act_model.add(
self.build_resblock(80, 2, name='Resnet_2', stride=2))
self.private_act_model.add(
self.build_resblock(128, 2, name='Resnet_3', stride=2))
self.private_act_model.add(
self.build_resblock(200, 2, name='Resnet_4', stride=2))
self.private_act_model.add(GlobalAveragePooling3D())
# self.private_act_model.add(Reshape((1, -1)))
# self.private_act_model.add(CuDNNLSTM(32))
self.private_act_model.add(
Dense(self.act_dim,
name="d1",
kernel_regularizer=regularizers.L2(0.001))) # action model
self.act_model = models.Sequential()
# self.act_model.add(self.shared_model)
self.act_model.add(self.private_act_model)
# output layer for move model
self.private_move_model.add(
Conv3D(64, (2, 3, 3),
strides=(1, 2, 2),
input_shape=self.input_shape,
name='conv1'))
# self.private_move_model.add(BatchNormalization(name='b1'))
self.private_move_model.add(Activation('relu'))
self.private_move_model.add(
MaxPooling3D(pool_size=(2, 2, 2),
strides=1,
padding="VALID",
name='p1'))
# resnet blocks
self.private_move_model.add(self.build_resblock(64, 2,
name='Resnet_1'))
self.private_move_model.add(
self.build_resblock(80, 2, name='Resnet_2', stride=2))
self.private_move_model.add(
self.build_resblock(128, 2, name='Resnet_3', stride=2))
self.private_move_model.add(
self.build_resblock(200, 2, name='Resnet_4', stride=2))
self.private_move_model.add(GlobalAveragePooling3D())
# self.private_move_model.add(Reshape((1, -1)))
# self.private_move_model.add(CuDNNLSTM(32))
self.private_move_model.add(
Dense(4, name="d1", kernel_regularizer=regularizers.L2(0.001)))
# action model
self.move_model = models.Sequential()
# self.move_model.add(self.shared_model)
self.move_model.add(self.private_move_model)
def ejer2_3():
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
mean_train = x_train.mean()
std_train = x_train.std()
n_clasifi = 10
X, Y = flattening(x_train, y_train, n_clasifi, mean_train, std_train)
X_test, Y_test = flattening(x_test, y_test, n_clasifi, mean_train,
std_train)
model = models.Sequential()
model.add(
layers.Dense(units=100,
input_shape=(X.shape[1], ),
use_bias=True,
activation=activations.sigmoid,
activity_regularizer=regularizers.L2(0.0001)))
model.add(
layers.Dense(units=10,
activity_regularizer=regularizers.L2(0.0001),
use_bias=True))
model.compile(optimizer=optimizers.SGD(0.003),
loss=losses.MSE,
metrics=['acc'])
n_epochs = 400
history = model.fit(X,
Y,
epochs=n_epochs,
batch_size=50,
validation_data=(X_test, Y_test))
acc_train = 100 * np.array(history.history['acc'])
acc_test = 100 * np.array(history.history['val_acc'])
loss_train = np.array(history.history['loss'])
loss_test_keras = np.array(history.history['val_loss'])
outputfile = 'ejer3_v2_mse.dat'
acc_vect, pres_vect, loss_vect, loss_test = np.loadtxt(outputfile,
unpack=True)
plt.figure(1)
plt.xlabel("Épocas")
epocas = np.arange(n_epochs)
plt.ylabel("Precisión [%]")
plt.plot(epocas,
acc_train,
label="Train - Keras ",
c='red',
alpha=0.6,
ls='--')
plt.plot(epocas, acc_test, label="Test - Keras", c='blue', alpha=0.6)
plt.plot(epocas,
acc_vect[:n_epochs],
label="Train",
c='green',
alpha=0.6,
ls='--')
plt.plot(epocas, pres_vect[:n_epochs], label="Test", c='orange', alpha=0.6)
plt.legend(loc=0)
plt.savefig("../docs/Figs/ejer2_3_acc.pdf")
plt.figure(2)
plt.xlabel("Épocas")
plt.ylabel("Pérdida")
plt.plot(epocas,
loss_train[:n_epochs] / np.max(loss_train[:n_epochs]),
label="Train - Keras",
c='red',
alpha=0.6,
ls='--')
plt.plot(epocas,
loss_test_keras[:n_epochs] / np.max(loss_test_keras[:n_epochs]),
label="Test - Keras",
c='blue',
alpha=0.6)
plt.plot(epocas,
loss_vect[:n_epochs] / np.max(loss_vect[:n_epochs]),
label="Train",
c='green',
alpha=0.6,
ls='--')
plt.plot(epocas,
loss_test[:n_epochs] / np.max(loss_test[:n_epochs]),
label="Test",
c='orange',
alpha=0.6)
plt.legend(loc=0)
plt.savefig("../docs/Figs/ejer2_3_loss.pdf")
plt.show()
fold_var = 1
x, y = data_loading()
for train_index, test_index in kf.split(x):
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
model = models.Sequential()
model.add(
layers.Dense(units=8,
input_shape=(x_train.shape[1], ),
use_bias=True,
activation=activations.relu,
activity_regularizer=regularizers.L2(0.000)))
model.add(
layers.Dense(units=5,
activity_regularizer=regularizers.L2(0.000),
activation=activations.relu,
use_bias=True))
model.add(
layers.Dense(units=1,
activity_regularizer=regularizers.L2(0.000),
activation=activations.linear,
use_bias=True))
model.compile(optimizer=optimizers.SGD(0.001),
loss=losses.MSE,
def _build_model(self):
init = 'glorot_uniform'
# action net
# ------------------ build evaluate_net ------------------
model = models.Sequential()
model.add(
Conv2D(16,
10,
strides=3,
input_shape=self.input_shape,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c1'))
model.add(BatchNormalization(name='b1'))
model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p1'))
model.add(
Conv2D(32,
7,
strides=2,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c2'))
model.add(BatchNormalization(name='b2'))
model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p2'))
model.add(
Conv2D(64,
5,
name='c3',
padding="SAME",
kernel_initializer=init,
activation='relu'))
model.add(BatchNormalization(name='b3'))
model.add(
MaxPooling2D(name='p3', pool_size=2, strides=2, padding="VALID"))
model.add(
Conv2D(64,
3,
name='c4',
padding="SAME",
kernel_initializer=init,
activation='relu'))
model.add(Flatten(name='f1'))
model.add(
Dense(256,
name='d1',
activation='relu',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
model.add(Dropout(0.5, name='dp1'))
model.add(
Dense(128,
name='d2',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
model.add(Dropout(0.5, name='dp2'))
model.add(
Dense(self.act_dim * self.act_seq,
name='d3',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001)))
model.summary()
self.act_model = model
# ------------------ build target_model ------------------
target_model = models.Sequential()
target_model.add(
Conv2D(16,
10,
strides=3,
input_shape=self.input_shape,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c1'))
target_model.add(BatchNormalization(name='b1'))
target_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p1'))
target_model.add(
Conv2D(32,
7,
strides=2,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c2'))
target_model.add(BatchNormalization(name='b2'))
target_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p2'))
target_model.add(
Conv2D(64,
5,
name='c3',
padding="SAME",
kernel_initializer=init,
activation='relu'))
target_model.add(BatchNormalization(name='b3'))
target_model.add(
MaxPooling2D(name='p3', pool_size=2, strides=2, padding="VALID"))
target_model.add(
Conv2D(64,
3,
name='c4',
padding="SAME",
kernel_initializer=init,
activation='relu'))
target_model.add(Flatten(name='f1'))
target_model.add(
Dense(256,
name='d1',
activation='relu',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
target_model.add(Dropout(0.5, name='dp1'))
target_model.add(
Dense(128,
name='d2',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
target_model.add(Dropout(0.5, name='dp2'))
target_model.add(
Dense(self.act_dim * self.act_seq,
name='d3',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001)))
target_model.summary()
self.act_target_model = target_model
# move net
# ------------------ build move_evaluate_net ------------------
move_model = models.Sequential()
move_model.add(
Conv2D(16,
10,
strides=3,
input_shape=self.input_shape,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c1'))
move_model.add(BatchNormalization(name='b1'))
move_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p1'))
move_model.add(
Conv2D(32,
7,
strides=2,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c2'))
move_model.add(BatchNormalization(name='b2'))
move_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p2'))
move_model.add(
Conv2D(64,
5,
name='c3',
padding="SAME",
kernel_initializer=init,
activation='relu'))
move_model.add(BatchNormalization(name='b3'))
move_model.add(
MaxPooling2D(name='p3', pool_size=2, strides=2, padding="VALID"))
move_model.add(
Conv2D(64,
3,
name='c4',
padding="SAME",
kernel_initializer=init,
activation='relu'))
move_model.add(Flatten(name='f1'))
move_model.add(
Dense(256,
name='d1',
activation='relu',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
move_model.add(Dropout(0.5, name='dp1'))
move_model.add(
Dense(128,
name='d2',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
move_model.add(Dropout(0.5, name='dp2'))
move_model.add(
Dense(3,
name='d3',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001)))
move_model.summary()
self.move_model = move_model
# ------------------ build move_target_model ------------------
move_target_model = models.Sequential()
move_target_model.add(
Conv2D(16,
10,
strides=3,
input_shape=self.input_shape,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c1'))
move_target_model.add(BatchNormalization(name='b1'))
move_target_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p1'))
move_target_model.add(
Conv2D(32,
7,
strides=2,
padding="SAME",
kernel_initializer=init,
activation='relu',
name='c2'))
move_target_model.add(BatchNormalization(name='b2'))
move_target_model.add(
MaxPooling2D(pool_size=2, strides=2, padding="VALID", name='p2'))
move_target_model.add(
Conv2D(64,
5,
name='c3',
padding="SAME",
kernel_initializer=init,
activation='relu'))
move_target_model.add(BatchNormalization(name='b3'))
move_target_model.add(
MaxPooling2D(name='p3', pool_size=2, strides=2, padding="VALID"))
move_target_model.add(
Conv2D(64,
3,
name='c4',
padding="SAME",
kernel_initializer=init,
activation='relu'))
move_target_model.add(Flatten(name='f1'))
move_target_model.add(
Dense(256,
name='d1',
activation='relu',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
move_target_model.add(Dropout(0.5, name='dp1'))
move_target_model.add(
Dense(128,
name='d2',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001),
kernel_initializer=init))
move_target_model.add(Dropout(0.5, name='dp2'))
move_target_model.add(
Dense(3,
name='d3',
activation='tanh',
kernel_regularizer=regularizers.L2(0.001)))
move_target_model.summary()
self.move_target_model = move_target_model
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)
numClasses = 5
model = tf.keras.Sequential([
tf.keras.layers.InputLayer(input_shape=(100, 100, 3)),
normalization_layer,
tf.keras.layers.ZeroPadding2D(),
tf.keras.layers.Conv2D(32,
5,
2,
padding='valid',
activation='relu',
kernel_regularizer=regularizers.L2(0.001)),
tf.keras.layers.MaxPooling2D(3, strides=None, padding='same'),
tf.keras.layers.Conv2D(64,
3,
1,
padding='valid',
activation='relu',
kernel_regularizer=regularizers.L2(0.001)),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Conv2D(256,
3,
2,
padding='valid',
activation='relu',
kernel_regularizer=regularizers.L2(0.001)),
tf.keras.layers.MaxPooling2D(3, strides=None, padding='valid'),
