#
DATA_PATH = './donquijote.txt'
LONG_SEC = 100 # Número de caracteres en cada ejemplo
# Lectura de datos y creación del set de entrenamiento
x_train, y_train, TAM_VOCAB, ix_to_char, char_to_ix = cargar_datos(
DATA_PATH, LONG_SEC)
#
# 1. MODELO: red LSTM con 1024 neuronas
#
modelo = Sequential()
modelo.add(LSTM(1024, input_shape=(None, 92), return_sequences=True))
modelo.add(TimeDistributed(Dense(92)))
modelo.add(Activation('softmax'))
#
# 2/3. COMPILACIÓN Y ENTRENAMIENTO DEL MODELO
#
modelo.compile(loss="categorical_crossentropy", optimizer="adam")
modelo.fit(x_train, y_train, batch_size=64, epochs=20, verbose=1)
#
# 4. PREDICCIÓN
#
print(generar_texto(modelo, 500, 92, ix_to_char))
# Secuencia de 500 caracteres generada
# ver lo que de mi padre le había de ser con la muerte de la
def five_images_to_LSF_model1():
input_lips = Input(shape=(5, 64, 64, 1))
# lips parts
lips_conv1_1 = TimeDistributed(
Conv2D(16, (5, 5), padding="same", activation="relu"))(input_lips)
lips_conv1_2 = TimeDistributed(
Conv2D(16, (5, 5), padding="same", activation="relu"))(lips_conv1_1)
lips_pooling1 = TimeDistributed(MaxPooling2D(pool_size=(2,
2)))(lips_conv1_2)
lips_conv2_1 = TimeDistributed(
Conv2D(32, (3, 3), padding="same", activation="relu"))(lips_pooling1)
lips_conv2_2 = TimeDistributed(
Conv2D(32, (3, 3), padding="same", activation="relu"))(lips_conv2_1)
lips_pooling2 = TimeDistributed(MaxPooling2D(pool_size=(2,
2)))(lips_conv2_2)
lips_conv3_1 = TimeDistributed(
Conv2D(64, (3, 3), padding="same", activation="relu"))(lips_pooling2)
lips_conv3_2 = TimeDistributed(
Conv2D(64, (3, 3), padding="same", activation="relu"))(lips_conv3_1)
lips_pooling3 = TimeDistributed(MaxPooling2D(pool_size=(2,
2)))(lips_conv3_2)
# tongues parts
input_tongues = Input(shape=(5, 64, 64, 1))
tongues_conv1_1 = TimeDistributed(
Conv2D(16, (5, 5), padding="same", activation="relu"))(input_tongues)
tongues_conv1_2 = TimeDistributed(
Conv2D(16, (5, 5), padding="same", activation="relu"))(tongues_conv1_1)
tongues_pooling1 = TimeDistributed(
MaxPooling2D(pool_size=(2, 2)))(tongues_conv1_2)
tongues_conv2_1 = TimeDistributed(
Conv2D(32, (3, 3), padding="same",
activation="relu"))(tongues_pooling1)
tongues_conv2_2 = TimeDistributed(
Conv2D(32, (3, 3), padding="same", activation="relu"))(tongues_conv2_1)
tongues_pooling2 = TimeDistributed(
MaxPooling2D(pool_size=(2, 2)))(tongues_conv2_2)
lips_flat_layer = TimeDistributed(Flatten())(lips_pooling3)
tongues_flat_layer = TimeDistributed(Flatten())(tongues_pooling2)
cc = concatenate([lips_flat_layer, tongues_flat_layer])
lstm1 = LSTM(1024, return_sequences=False)(cc)
lstm_dr1 = Dropout(0.2)(lstm1)
fc = Dense(13, activation="linear")(lstm_dr1)
mymodel = Model([input_lips, input_tongues], fc)
return mymodel
def simple_cnn_1D(args):
#
# Model parameters
#
model_type = args.model_type
input_shape = args.input_shape
n_convs = args.n_layers_convs
n_dense = args.n_layers_dense
max_str_len = args.max_str_len
num_classes = args.num_classes
activation = args.act
advanced_act = args.aact
padding = args.padding
start_filter = args.sf_dim
kernel_size = args.kernel_size
kernel_init = args.kernel_init
l2_reg = args.l2_reg
shared_axes = args.shared_axes
opt = args.opt
#
# Layer parameters
#
# Conv layers parameters
convArgs = {
"activation": activation,
"data_format": "channels_last",
"padding": padding,
"bias_initializer": "zeros",
"kernel_regularizer": l2(l2_reg),
"kernel_initializer": kernel_init,
"use_bias": True
}
# Dense layers parameters
denseArgs = {
"activation": activation,
"kernel_regularizer": l2(l2_reg),
"kernel_initializer": kernel_init, # "glorot_normal"
"bias_initializer": "zeros",
"use_bias": True
}
#
# Model building
#
# Input Stage
if model_type == "quaternion":
quat_init = 'quaternion'
convArgs.update({"kernel_initializer": quat_init})
input_data = Input(name='the_input', shape=input_shape, dtype='float64')
# Convolutional Stage
if model_type == 'real':
# batch-normalization
O = BatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(input_data)
for idx in range(n_convs):
conv_filters = start_filter * (2**idx)
O = Conv1D(conv_filters,
kernel_size,
name='conv_{}'.format(idx),
**convArgs)(O)
if advanced_act == 'prelu':
O = PReLU()(O)
# batch-normalization
O = BatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
else:
# batch-normalization
O = QuaternionBatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(input_data)
for idx in range(n_convs):
conv_filters = start_filter * (2**idx)
O = QuaternionConv1D(conv_filters,
kernel_size,
name='conv_{}'.format(idx),
**convArgs)(O)
if advanced_act == 'prelu':
O = PReLU()(O)
# batch-normalization
O = QuaternionBatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
# conv_shape = O.shape
# reshape
# O = Reshape(target_shape=[K.int_shape(O)[1] * K.int_shape(O)[2]])(O)
# Fully-Connected Stage
if model_type == 'real':
for idx in range(n_dense):
O = TimeDistributed(
Dense(1024, **denseArgs, name='dense_{}'.format(idx)))(O)
if advanced_act == 'prelu':
O = PReLU()(O)
# batch-normalization
O = BatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
else:
for idx in range(n_dense):
O = TimeDistributed(
QuaternionDense(256, **denseArgs,
name='dense_{}'.format(idx)))(O)
if advanced_act == 'prelu':
O = PReLU()(O)
# batch-normalization
O = QuaternionBatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
#
# Prediction (Output) Stage
#
inner = Dense(num_classes,
kernel_regularizer=l2(l2_reg),
use_bias=True,
bias_initializer="zeros",
kernel_initializer=kernel_init)(O)
y_pred = Activation('softmax', name='softmax')(inner)
# Print summary of neural model
Model(inputs=input_data, outputs=y_pred).summary()
labels = Input(name='the_labels', shape=[max_str_len], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
loss_out = Lambda(ctc_lambda_func, output_shape=(1, ),
name='ctc')([y_pred, labels, input_length, label_length])
# clipnorm seems to speeds up convergence
# sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
opt_dict = {
'adam': Adam(lr=0.02, clipnorm=5),
'sgd': SGD(lr=0.02,
decay=1e-6,
momentum=0.9,
nesterov=True,
clipnorm=5)
}
optimizer = opt_dict[opt]
model = Model(inputs=[input_data, labels, input_length, label_length],
outputs=loss_out)
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss={
'ctc': lambda y_true, y_pred: y_pred
},
optimizer=optimizer)
return model
def build_model(X_Train, Y_Train, n_input, X_Test, Y_Test):
# mini-bacht gradient descent als Trainingsalgorithmen ausgewählt
#(Sequenzgroße=14 <Batch-Size < Große des Trainingsdatensatzes )
# So wurde die Batch-Size als vielfacheit der Eingangs- und Ausgangssequenzlänge gewählt
verbose, epochs, batch_size = 1, 3000, 28
n_daysteps, n_features, n_outputs = X_Train.shape[1], X_Train.shape[
2], Y_Train.shape[1]
Y_Train = Y_Train.reshape((Y_Train.shape[0], Y_Train.shape[1], 1))
#Neues leeres Modell anlegen
model = Sequential()
model.add(
LSTM(256, activation='relu', input_shape=(n_daysteps, n_features)))
model.add(BatchNormalization())
model.add(RepeatVector(n_outputs))
model.add(LSTM(256, activation='relu', return_sequences=True))
model.add(BatchNormalization())
model.add(TimeDistributed(Dense(128, activation='relu')))
model.add(TimeDistributed(Dense(1)))
model.compile(loss='mae', optimizer='adam', metrics=['acc', 'mae'])
# Modell trainieren
#X_Val, Y_Val = X_Train[-val_split:], Y_Train[-val_split:]
history = model.fit(X_Train,
Y_Train,
epochs=epochs,
batch_size=batch_size,
validation_data=(X_Test, Y_Test),
verbose=verbose)
# Model Architektur
print(model.summary())
acc = history.history['acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
#plotting training and validation loss
plt.plot(epochs, loss, label='Training loss')
plt.plot(epochs, val_loss, label='validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
#plotting training and validation accuracy
plt.clf()
#val_acc = history.history['val_acc']
#plt.plot(epochs, acc, label='Training acc')
#plt.plot(epochs, val_acc, label='Validation acc')
# plt.title('Training and validation accuracy')
# plt.xlabel('Epochs')
# plt.ylabel('acc')
# plt.legend()
# plt.show()
model.save('LSTM_Model_14_2to1.h5')
return model
def _build_model(self, x, y):
"""Construct ASAC model using feature and label statistics.
Args:
- x: temporal feature
- y: labels
Returns:
- model: asac model
"""
# Parameters
h_dim = self.h_dim
n_layer = self.n_layer
dim = len(x[0, 0, :])
max_seq_len = len(x[0, :, 0])
# Build one input, two outputs model
main_input = Input(shape=(max_seq_len, dim), dtype='float32')
mask_layer = Masking(mask_value=-1.)(main_input)
previous_input = Input(shape=(max_seq_len, dim), dtype='float32')
previous_mask_layer = Masking(mask_value=-1.)(previous_input)
select_layer = rnn_layer(previous_mask_layer,
self.model_type,
h_dim,
return_seq=True)
for _ in range(n_layer):
select_layer = rnn_layer(select_layer,
self.model_type,
h_dim,
return_seq=True)
select_layer = TimeDistributed(Dense(
dim, activation='sigmoid'))(select_layer)
# Sampling the selection
select_layer = Lambda(lambda x: x - 0.5)(select_layer)
select_layer = Activation('relu')(select_layer)
select_out = Lambda(lambda x: x * 2, name='select')(select_layer)
# Second output
pred_layer = Multiply()([mask_layer, select_out])
for _ in range(n_layer - 1):
pred_layer = rnn_layer(pred_layer,
self.model_type,
h_dim,
return_seq=True)
return_seq_bool = len(y.shape) == 3
pred_layer = rnn_layer(pred_layer, self.model_type, h_dim,
return_seq_bool)
if self.task == 'classification': act_fn = 'sigmoid'
elif self.task == 'regression': act_fn = 'linear'
if len(y.shape) == 3:
pred_out = TimeDistributed(Dense(y.shape[-1], activation=act_fn),
name='predict')(pred_layer)
elif len(y.shape) == 2:
pred_out = Dense(y.shape[-1], activation=act_fn,
name='predict')(pred_layer)
model = Model(inputs=[main_input, previous_input],
outputs=[select_out, pred_out])
# Optimizer
adam = tf.keras.optimizers.Adam(learning_rate=self.learning_rate,
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
# Model compile
if self.task == 'classification':
model.compile(loss={
'select': select_loss,
'predict': binary_cross_entropy_loss
},
optimizer=adam,
loss_weights={
'select': 0.01,
'predict': 1
})
elif self.task == 'regression':
model.compile(loss={
'select': select_loss,
'predict': rmse_loss
},
optimizer=adam,
loss_weights={
'select': 0.01,
'predict': 1
})
return model
def PanopticNet(backbone,
input_shape,
inputs=None,
backbone_levels=['C3', 'C4', 'C5'],
pyramid_levels=['P3', 'P4', 'P5', 'P6', 'P7'],
create_pyramid_features=__create_pyramid_features,
create_semantic_head=__create_semantic_head,
frames_per_batch=1,
temporal_mode=None,
num_semantic_classes=[3],
required_channels=3,
norm_method=None,
pooling=None,
location=True,
use_imagenet=True,
lite=False,
upsample_type='upsampling2d',
interpolation='bilinear',
name='panopticnet',
z_axis_convolutions=False,
**kwargs):
"""Constructs a Mask-RCNN model using a backbone from
``keras-applications`` with optional semantic segmentation transforms.
Args:
backbone (str): Name of backbone to use.
input_shape (tuple): The shape of the input data.
backbone_levels (list): The backbone levels to be used.
to create the feature pyramid.
pyramid_levels (list): Pyramid levels to use.
create_pyramid_features (function): Function to get the pyramid
features from the backbone.
create_semantic_head (function): Function to build a semantic head
submodel.
frames_per_batch (int): Size of z axis in generated batches.
If equal to 1, assumes 2D data.
temporal_mode: Mode of temporal convolution. Choose from
``{'conv','lstm','gru', None}``.
num_semantic_classes (list or dict): Number of semantic classes
for each semantic head. If a ``dict``, keys will be used as
head names and values will be the number of classes.
norm_method (str): Normalization method to use with the
:mod:`deepcell.layers.normalization.ImageNormalization2D` layer.
location (bool): Whether to include a
:mod:`deepcell.layers.location.Location2D` layer.
use_imagenet (bool): Whether to load imagenet-based pretrained weights.
lite (bool): Whether to use a depthwise conv in the feature pyramid
rather than regular conv.
upsample_type (str): Choice of upsampling layer to use from
``['upsamplelike', 'upsampling2d', 'upsampling3d']``.
interpolation (str): Choice of interpolation mode for upsampling
layers from ``['bilinear', 'nearest']``.
pooling (str): optional pooling mode for feature extraction
when ``include_top`` is ``False``.
- None means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- 'avg' means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- 'max' means that global max pooling will
be applied.
z_axis_convolutions (bool): Whether or not to do convolutions on
3D data across the z axis.
required_channels (int): The required number of channels of the
backbone. 3 is the default for all current backbones.
kwargs (dict): Other standard inputs for ``retinanet_mask``.
Raises:
ValueError: ``temporal_mode`` not 'conv', 'lstm', 'gru' or ``None``
Returns:
tensorflow.keras.Model: Panoptic model with a backbone.
"""
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
conv = Conv3D if frames_per_batch > 1 else Conv2D
conv_kernel = (1, 1, 1) if frames_per_batch > 1 else (1, 1)
# Check input to __merge_temporal_features
acceptable_modes = {'conv', 'lstm', 'gru', None}
if temporal_mode is not None:
temporal_mode = str(temporal_mode).lower()
if temporal_mode not in acceptable_modes:
raise ValueError('temporal_mode {} not supported. Please choose '
'from {}.'.format(temporal_mode, acceptable_modes))
# TODO only works for 2D: do we check for 3D as well?
# What are the requirements for 3D data?
img_shape = input_shape[1:] if channel_axis == 1 else input_shape[:-1]
if img_shape[0] != img_shape[1]:
raise ValueError('Input data must be square, got dimensions {}'.format(
img_shape))
if not math.log(img_shape[0], 2).is_integer():
raise ValueError('Input data dimensions must be a power of 2, '
'got {}'.format(img_shape[0]))
# Check input to interpolation
acceptable_interpolation = {'bilinear', 'nearest'}
if interpolation not in acceptable_interpolation:
raise ValueError('Interpolation mode "{}" not supported. '
'Choose from {}.'.format(
interpolation, list(acceptable_interpolation)))
if inputs is None:
if frames_per_batch > 1:
if channel_axis == 1:
input_shape_with_time = tuple(
[input_shape[0], frames_per_batch] + list(input_shape)[1:])
else:
input_shape_with_time = tuple(
[frames_per_batch] + list(input_shape))
inputs = Input(shape=input_shape_with_time, name='input_0')
else:
inputs = Input(shape=input_shape, name='input_0')
# Normalize input images
if norm_method is None:
norm = inputs
else:
if frames_per_batch > 1:
norm = TimeDistributed(ImageNormalization2D(
norm_method=norm_method, name='norm'), name='td_norm')(inputs)
else:
norm = ImageNormalization2D(norm_method=norm_method,
name='norm')(inputs)
# Add location layer
if location:
if frames_per_batch > 1:
# TODO: TimeDistributed is incompatible with channels_first
loc = TimeDistributed(Location2D(name='location'),
name='td_location')(norm)
else:
loc = Location2D(name='location')(norm)
concat = Concatenate(axis=channel_axis,
name='concatenate_location')([norm, loc])
else:
concat = norm
# Force the channel size for backbone input to be `required_channels`
fixed_inputs = conv(required_channels, conv_kernel, strides=1,
padding='same', name='conv_channels')(concat)
# Force the input shape
axis = 0 if K.image_data_format() == 'channels_first' else -1
fixed_input_shape = list(input_shape)
fixed_input_shape[axis] = required_channels
fixed_input_shape = tuple(fixed_input_shape)
model_kwargs = {
'include_top': False,
'weights': None,
'input_shape': fixed_input_shape,
'pooling': pooling
}
_, backbone_dict = get_backbone(backbone, fixed_inputs,
use_imagenet=use_imagenet,
frames_per_batch=frames_per_batch,
return_dict=True,
**model_kwargs)
backbone_dict_reduced = {k: backbone_dict[k] for k in backbone_dict
if k in backbone_levels}
ndim = 2 if frames_per_batch == 1 else 3
pyramid_dict = create_pyramid_features(backbone_dict_reduced,
ndim=ndim,
lite=lite,
interpolation=interpolation,
upsample_type=upsample_type,
z_axis_convolutions=z_axis_convolutions)
features = [pyramid_dict[key] for key in pyramid_levels]
if frames_per_batch > 1:
temporal_features = [__merge_temporal_features(f, mode=temporal_mode,
frames_per_batch=frames_per_batch)
for f in features]
for f, k in zip(temporal_features, pyramid_levels):
pyramid_dict[k] = f
semantic_levels = [int(re.findall(r'\d+', k)[0]) for k in pyramid_dict]
target_level = min(semantic_levels)
semantic_head_list = []
if not isinstance(num_semantic_classes, dict):
num_semantic_classes = {
k: v for k, v in enumerate(num_semantic_classes)
}
for k, v in num_semantic_classes.items():
semantic_head_list.append(create_semantic_head(
pyramid_dict, n_classes=v,
input_target=inputs, target_level=target_level,
semantic_id=k, ndim=ndim, upsample_type=upsample_type,
interpolation=interpolation, **kwargs))
outputs = semantic_head_list
model = Model(inputs=inputs, outputs=outputs, name=name)
return model
def get_test_model_recurrent():
"""Returns a minimalistic test model for recurrent layers."""
input_shapes = [(17, 4), (1, 10), (20, 40), (6, 7, 10, 3)]
outputs = []
inputs = [Input(shape=s) for s in input_shapes]
inp = PReLU()(inputs[0])
lstm = Bidirectional(
LSTM(
units=4,
return_sequences=True,
bias_initializer=
'random_uniform', # default is zero use random to test computation
activation='tanh',
recurrent_activation='relu'),
merge_mode='concat')(inp)
lstm2 = Bidirectional(LSTM(units=6,
return_sequences=True,
bias_initializer='random_uniform',
activation='elu',
recurrent_activation='hard_sigmoid'),
merge_mode='sum')(lstm)
lstm3 = LSTM(units=10,
return_sequences=False,
bias_initializer='random_uniform',
activation='selu',
recurrent_activation='sigmoid')(lstm2)
outputs.append(lstm3)
conv1 = Conv1D(2, 1, activation='sigmoid')(inputs[1])
lstm4 = LSTM(units=15,
return_sequences=False,
bias_initializer='random_uniform',
activation='tanh',
recurrent_activation='elu')(conv1)
dense = (Dense(23, activation='sigmoid'))(lstm4)
outputs.append(dense)
time_dist_1 = TimeDistributed(Conv2D(2, (3, 3), use_bias=True))(inputs[3])
flatten_1 = TimeDistributed(Flatten())(time_dist_1)
outputs.append(
Bidirectional(LSTM(units=6,
return_sequences=True,
bias_initializer='random_uniform',
activation='tanh',
recurrent_activation='sigmoid'),
merge_mode='ave')(flatten_1))
outputs.append(TimeDistributed(MaxPooling2D(2, 2))(inputs[3]))
outputs.append(TimeDistributed(AveragePooling2D(2, 2))(inputs[3]))
outputs.append(TimeDistributed(BatchNormalization())(inputs[3]))
nested_inputs = Input(shape=input_shapes[0][1:])
nested_x = Dense(5, activation='relu')(nested_inputs)
nested_predictions = Dense(3, activation='softmax')(nested_x)
nested_model = Model(inputs=nested_inputs, outputs=nested_predictions)
nested_model.compile(loss='categorical_crossentropy', optimizer='nadam')
outputs.append(TimeDistributed(nested_model)(inputs[0]))
nested_sequential_model = Sequential()
nested_sequential_model.add(Flatten(input_shape=input_shapes[0][1:]))
nested_sequential_model.compile(optimizer='rmsprop',
loss='categorical_crossentropy')
outputs.append(TimeDistributed(nested_sequential_model)(inputs[0]))
model = Model(inputs=inputs, outputs=outputs, name='test_model_recurrent')
model.compile(loss='mse', optimizer='nadam')
# fit to dummy data
training_data_size = 2
data_in = generate_input_data(training_data_size, input_shapes)
initial_data_out = model.predict(data_in)
data_out = generate_output_data(training_data_size, initial_data_out)
model.fit(data_in, data_out, epochs=10)
return model
def build_transformer(source_vocabulary_size,
target_vocabulary_size,
max_length,
share_word_embedding=False,
n=6,
h=8,
d_k=64,
d_v=64,
d_model=512,
optimizer="adam",
null_token_value=0):
source_input = Input(shape=(None, ), name="source_input")
target_input = Input(shape=(None, ), name="target_input")
enc_input = Lambda(lambda x: x[:, 1:])(source_input)
dec_input = Lambda(lambda x: x[:, :-1])(target_input)
dec_target_output = Lambda(lambda x: x[:, 1:])(target_input)
# create embedding
source_word_embedding = Embedding(
source_vocabulary_size,
d_model,
name="source_embedding" if share_word_embedding else "source_embedding"
) # weights=[_get_positional_encoding_matrix(max_length, d_model)]
if share_word_embedding:
target_word_embedding = source_word_embedding
else:
target_word_embedding = Embedding(target_vocabulary_size,
d_model,
name="target_embedding")
# embedding for the position encoding
position_encoding = Embedding(
max_length,
d_model,
trainable=False,
weights=[_get_positional_encoding_matrix(max_length, d_model)],
name="position_embedding")
enc = Encoder(source_word_embedding,
position_encoding,
n=n,
h=h,
d_k=d_k,
d_v=d_v,
d_model=d_model,
d_inner_hid=512)
dec = Decoder(target_word_embedding,
position_encoding,
n=n,
h=h,
d_k=d_k,
d_v=d_v,
d_model=d_model,
d_inner_hid=512)
enc_output = enc(enc_input)
dec_output = dec(dec_input, enc_output)
# lin_dense = TimeDistributed(Dense(d_model))
fin_output = TimeDistributed(Dense(target_vocabulary_size,
activation=None,
use_bias=False),
name="output") # "softmax"
# lin_dense_out = lin_dense(dec_output)
fin_output_out = fin_output(dec_output) # lin_dense_out)
accuracy = Lambda(_get_accuracy,
arguments={"null_token_value": null_token_value
})([fin_output_out, dec_target_output])
loss = Lambda(_get_loss, arguments={"null_token_value": null_token_value
})([fin_output_out, dec_target_output])
train_model = Model(inputs=[source_input, target_input], outputs=loss)
train_model.add_loss([loss])
train_model.compile(optimizer, None)
train_model.metrics_names.append('accuracy')
# when using tf.keras
#train_model.metrics_tensors.append(accuracy)
train_model.metrics.append(accuracy)
inference_model = Model([source_input, target_input], fin_output_out)
return train_model, inference_model
signature="tokens",
as_dict=True)["elmo"]
from tensorflow.keras.layers import Dense, Flatten, Embedding, LSTM, TimeDistributed, Dropout, Bidirectional, Lambda
from tensorflow.keras.models import Model
from tensorflow.keras.layers import concatenate
from tensorflow.keras import Input
input = Input(shape=(max_len,), dtype=tf.string)
embeddings = Lambda(ElmoEmbedding, output_shape=(max_len, 1024))(input)
x = Bidirectional(LSTM(units=512, return_sequences=True, recurrent_dropout=0.2, dropout=0.2))(embeddings)
x_rnn = Bidirectional(LSTM(units=512, return_sequences=True, recurrent_dropout=0.2, dropout=0.2))(x)
x = concatenate([x, x_rnn])
out = TimeDistributed(Dense(n_tags, activation='softmax'))(x)
model = Model(input, out)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
X_tr, X_val = X_train[:1213*batch_size], X_train[-135*batch_size:]
y_tr, y_val = y_train[:1213*batch_size], y_train[-135*batch_size:]
y_tr = y_tr.reshape(y_tr.shape[0], y_tr.shape[1], 1)
y_val = y_val.reshape(y_val.shape[0], y_val.shape[1], 1)
m = np.array(X_tr)
print(m.shape)
n = np.array(X_val)
print(n.shape)
history = model.fit(np.array(X_tr), y_tr, validation_data=(np.array(X_val), y_val),
def __init__(self, window, hop=None):
super(MOSNet, self).__init__(name='MOSNet', window=window, hop=hop)
# constants
self.fixed_rate = 16000
self.mono = True
self.absolute = True
self.FFT_SIZE = 512
self.SGRAM_DIM = self.FFT_SIZE // 2 + 1
self.HOP_LENGTH = 256
self.WIN_LENGTH = 512
self.model = dotdict({'predict': None})
pre_trained_dir = os.path.dirname(__file__)
try:
tflite_model = open(os.path.join(pre_trained_dir, 'mosnet.tflite'),
"rb").read()
#converter = tf.lite.TFLiteConverter.from_keras_model(self.model)
##converter.optimizations = [tf.lite.Optimize.DEFAULT]
#tflite_model = converter.convert()
#open(os.path.join(pre_trained_dir, 'mosnet.tflite'), "wb").write(tflite_model)
self.interpreter = tf.lite.Interpreter(model_content=tflite_model)
self.interpreter.allocate_tensors()
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()
self.input_shape = self.input_details[0]['shape']
def predict(mag, verbose, batch_size):
self.interpreter.resize_tensor_input(
self.input_details[0]['index'], mag.shape)
self.interpreter.allocate_tensors()
self.interpreter.set_tensor(self.input_details[0]['index'],
mag)
self.interpreter.invoke()
return self.interpreter.get_tensor(
self.output_details[0]['index'])
self.model.predict = predict
return
except:
raise
_input = keras.Input(shape=(None, 257)) #shape=(0, 257))
re_input = layers.Reshape((-1, 257, 1),
input_shape=(None, 257))(_input)
# CNN
conv1 = (Conv2D(16, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(re_input)
conv1 = (Conv2D(16, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv1)
conv1 = (Conv2D(16, (3, 3),
strides=(1, 3),
activation='relu',
padding='same'))(conv1)
conv2 = (Conv2D(32, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv1)
conv2 = (Conv2D(32, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv2)
conv2 = (Conv2D(32, (3, 3),
strides=(1, 3),
activation='relu',
padding='same'))(conv2)
conv3 = (Conv2D(64, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv2)
conv3 = (Conv2D(64, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv3)
conv3 = (Conv2D(64, (3, 3),
strides=(1, 3),
activation='relu',
padding='same'))(conv3)
conv4 = (Conv2D(128, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv3)
conv4 = (Conv2D(128, (3, 3),
strides=(1, 1),
activation='relu',
padding='same'))(conv4)
conv4 = (Conv2D(128, (3, 3),
strides=(1, 3),
activation='relu',
padding='same'))(conv4)
re_shape = layers.Reshape((-1, 4 * 128),
input_shape=(-1, 4, 128))(conv4)
# BLSTM
blstm1 = Bidirectional(LSTM(128,
return_sequences=True,
dropout=0.3,
recurrent_dropout=0.3,
recurrent_constraint=max_norm(0.00001)),
merge_mode='concat')(re_shape)
# DNN
flatten = TimeDistributed(layers.Flatten())(blstm1)
dense1 = TimeDistributed(Dense(128, activation='relu'))(flatten)
dense1 = Dropout(0.3)(dense1)
frame_score = TimeDistributed(Dense(1), name='frame')(dense1)
import warnings
average_score = layers.GlobalAveragePooling1D(name='avg')(frame_score)
self.model = Model(outputs=[average_score, frame_score], inputs=_input)
# weights are in the directory of this file
# load pre-trained weights. CNN_BLSTM is reported as best
self.model.load_weights(os.path.join(pre_trained_dir, 'cnn_blstm.h5'))
input_dim = x_train_loaded.shape[2]
encoding_dim = n_steps * n_features
# Encoder
encoder = Sequential(name='Encoder')
encoder.add(
LSTM(encoding_dim,
activation='relu',
input_shape=(n_steps, input_dim),
name='encoderlayer1'))
# Decoder
decoder = Sequential(name='Decoder')
decoder.add(RepeatVector(n_steps))
decoder.add(LSTM(encoding_dim, return_sequences=True, name='decoderlayer1'))
decoder.add(TimeDistributed(Dense(input_dim)))
# Compile and fit autoencoder
SAE = Sequential([encoder, decoder], name='SAE')
SAE.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
encoder.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
SAE_history = SAE.fit(x_train_loaded,
x_train_loaded,
epochs=epochs,
batch_size=batch_size)
# Save model
SAE.save('Models/SAE_train_5timestep_%s.h5' % today)
encoder.save('Models/Encoder_train_5timestep_%s.h5' % today)
# Note, the following assumes that you have the graphviz graph library and the Python interface installed
def create_lstm_vae_model(batch_size, time_steps, number_of_features, int_dim,
latent_dim):
def vae_sampling(args):
z_mean, z_log_sigma = args
batch_size = shape(z_mean)[0]
latent_dim = shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0,
stddev=1)
return z_mean + K.exp(z_log_sigma / 2) * epsilon
# Encoder
input_x = Input(shape=(time_steps, number_of_features))
encoder_LSTM_int = LSTM(int_dim, return_sequences=True)(input_x)
encoder_LSTM_latent = LSTM(latent_dim,
return_sequences=False)(encoder_LSTM_int)
z_mean = Dense(latent_dim)(encoder_LSTM_latent)
z_log_sigma = Dense(latent_dim)(encoder_LSTM_latent)
z_encoder_output = Lambda(
vae_sampling, output_shape=(latent_dim, ))([z_mean, z_log_sigma])
encoder = Model(input_x, [z_mean, z_log_sigma, z_encoder_output])
# Decoder
decoder_input = Input(shape=(latent_dim))
decoder_repeated = RepeatVector(time_steps)(decoder_input)
decoder_LSTM_int = LSTM(int_dim, return_sequences=True)(decoder_repeated)
decoder_LSTM = LSTM(number_of_features,
return_sequences=True)(decoder_LSTM_int)
decoder_dense1 = TimeDistributed(Dense(number_of_features *
2))(decoder_LSTM)
decoder_output = TimeDistributed(Dense(number_of_features))(decoder_LSTM)
decoder = Model(decoder_input, decoder_output)
# VAE
output = decoder(
encoder(input_x)[2]
) # this is the part encoder and decoder are connected together. Decoder takes the encoder output's[2] as input
lstm_vae = keras.Model(input_x, output, name='lstm_vae')
# Loss
reconstruction_loss = mse(input_x, output)
reconstruction_loss *= number_of_features
kl_loss = 1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma)
kl_loss = K.sum(kl_loss)
kl_loss *= -0.5
vae_loss = K.mean(reconstruction_loss + kl_loss)
lstm_vae.add_loss(vae_loss)
return encoder, decoder, lstm_vae #
def all_metrics_together(y, y_hat):
accuracy = metrics.accuracy_score(y, y_hat)
recall = metrics.recall_score(y, y_hat)
precision = metrics.precision_score(y, y_hat)
f1 = metrics.f1_score(y, y_hat)
df = pd.DataFrame(
{
'Accuracy': accuracy,
'Recall': recall,
'Precision': precision,
'F1': f1
},
index=['metric_value'])
return df
def call(self, inputs, training=None, mask=None):
conv1 = TimeDistributed(MaxPool2D(
(2, 2)))(TimeDistributed(self.conv1)(inputs))
conv2 = TimeDistributed(MaxPool2D(
(2, 2)))(TimeDistributed(self.conv2)(conv1))
return TimeDistributed(self.flat)(conv2)
def output_layer(self):
return TimeDistributed(Dense(self.token_count, activation='softmax'))
def __init__(self, dim, batch_norm, dropout, rec_dropout, partition,
ihm_pos, target_repl=False, depth=1, input_dim=76, **kwargs):
print("==> not used params in network class:", kwargs.keys())
self.dim = dim
self.batch_norm = batch_norm
self.dropout = dropout
self.rec_dropout = rec_dropout
self.depth = depth
# Input layers and masking
X = Input(shape=(None, input_dim), name='X')
mX = Masking()(X)
# Masks
ihm_M = Input(shape=(1,), name='ihm_M')
decomp_M = Input(shape=(None,), name='decomp_M')
los_M = Input(shape=(None,), name='los_M')
inputs = [X, ihm_M, decomp_M, los_M]
# Main part of the network
for i in range(depth):
mX = LSTM(units=dim,
activation='tanh',
return_sequences=True,
recurrent_dropout=rec_dropout,
dropout=dropout)(mX)
L = mX
if dropout > 0:
L = Dropout(dropout)(L)
# Output modules
outputs = []
# ihm output
# NOTE: masking for ihm prediction works this way:
# if ihm_M = 1 then we will calculate an error term
# if ihm_M = 0, our prediction will be 0 and as the label
# will also be 0 then error_term will be 0.
if target_repl > 0:
ihm_seq = TimeDistributed(Dense(1, activation='sigmoid'), name='ihm_seq')(L)
ihm_y = GetTimestep(ihm_pos)(ihm_seq)
ihm_y = Multiply(name='ihm_single')([ihm_y, ihm_M])
outputs += [ihm_y, ihm_seq]
else:
ihm_seq = TimeDistributed(Dense(1, activation='sigmoid'))(L)
ihm_y = GetTimestep(ihm_pos)(ihm_seq)
ihm_y = Multiply(name='ihm')([ihm_y, ihm_M])
outputs += [ihm_y]
# decomp output
decomp_y = TimeDistributed(Dense(1, activation='sigmoid'))(L)
decomp_y = ExtendMask(name='decomp', add_epsilon=True)([decomp_y, decomp_M])
outputs += [decomp_y]
# los output
if partition == 'none':
los_y = TimeDistributed(Dense(1, activation='relu'))(L)
else:
los_y = TimeDistributed(Dense(10, activation='softmax'))(L)
los_y = ExtendMask(name='los', add_epsilon=True)([los_y, los_M])
outputs += [los_y]
# pheno output
if target_repl:
pheno_seq = TimeDistributed(Dense(25, activation='sigmoid'), name='pheno_seq')(L)
pheno_y = LastTimestep(name='pheno_single')(pheno_seq)
outputs += [pheno_y, pheno_seq]
else:
pheno_seq = TimeDistributed(Dense(25, activation='sigmoid'))(L)
pheno_y = LastTimestep(name='pheno')(pheno_seq)
outputs += [pheno_y]
super(Network, self).__init__(inputs=inputs, outputs=outputs)
def interspeech_TIMIT_Model(d):
n = d.num_layers
sf = d.start_filter
activation = d.act
advanced_act = d.aact
drop_prob = d.dropout
inputShape = (778, 3, 40) # (3,41,None)
filsize = (3, 5)
Axis = 1
if advanced_act != "none":
activation = 'linear'
convArgs = {
"activation": activation,
"data_format": "channels_first",
"padding": "same",
"bias_initializer": "zeros",
"kernel_regularizer": l2(d.l2),
"kernel_initializer": "random_uniform",
}
denseArgs = {
"activation": d.act,
"kernel_regularizer": l2(d.l2),
"kernel_initializer": "random_uniform",
"bias_initializer": "zeros",
"use_bias": True
}
#### Check kernel_initializer for quaternion model ####
if d.model == "quaternion":
convArgs.update({"kernel_initializer": d.quat_init})
#
# Input Layer & CTC Parameters for TIMIT
#
if d.model == "quaternion":
I = Input(shape=(778, 4, 40)) # Input(shape=(4,41,None))
else:
I = Input(shape=inputShape)
labels = Input(name='the_labels', shape=[None], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
#
# Input stage:
#
if d.model == "real":
O = Conv2D(sf, filsize, name='conv', use_bias=True, **convArgs)(I)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
else:
O = QuaternionConv2D(sf,
filsize,
name='conv',
use_bias=True,
**convArgs)(I)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
#
# Pooling
#
O = MaxPooling2D(pool_size=(1, 3), padding='same')(O)
#
# Stage 1
#
for i in range(0, n // 2):
if d.model == "real":
O = Conv2D(sf,
filsize,
name='conv' + str(i),
use_bias=True,
**convArgs)(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
else:
O = QuaternionConv2D(sf,
filsize,
name='conv' + str(i),
use_bias=True,
**convArgs)(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
#
# Stage 2
#
for i in range(0, n // 2):
if d.model == "real":
O = Conv2D(sf * 2,
filsize,
name='conv' + str(i + n / 2),
use_bias=True,
**convArgs)(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
else:
O = QuaternionConv2D(sf * 2,
filsize,
name='conv' + str(i + n / 2),
use_bias=True,
**convArgs)(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
#
# Permutation for CTC
#
print("Last Q-Conv2D Layer (output): ", K.int_shape(O))
print("Shape tuple: ",
K.int_shape(O)[0],
K.int_shape(O)[1],
K.int_shape(O)[2],
K.int_shape(O)[3])
#### O = Permute((3,1,2))(O)
#### print("Last Q-Conv2D Layer (Permute): ", O.shape)
# O = Lambda(lambda x: K.reshape(x, (K.shape(x)[0], K.shape(x)[1],
# K.shape(x)[2] * K.shape(x)[3])),
# output_shape=lambda x: (None, None, x[2] * x[3]))(O)
# O = Lambda(lambda x: K.reshape(x, (K.int_shape(x)[0], K.int_shape(x)[1],
# K.int_shape(x)[2] * K.int_shape(x)[3])),
# output_shape=lambda x: (None, None, x[2] * x[3]))(O)
O = tf.keras.layers.Reshape(
target_shape=[-1, K.int_shape(O)[2] * K.int_shape(O)[3]])(O)
#
# Dense
#
print("Q-Dense input: ", K.int_shape(O))
if d.model == "quaternion":
print("first Q-dense layer: ", O.shape)
O = TimeDistributed(QuaternionDense(256, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
O = TimeDistributed(QuaternionDense(256, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
O = TimeDistributed(QuaternionDense(256, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
else:
O = TimeDistributed(Dense(1024, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
O = TimeDistributed(Dense(1024, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
O = Dropout(drop_prob)(O)
O = TimeDistributed(Dense(1024, **denseArgs))(O)
if advanced_act == "prelu":
O = PReLU(shared_axes=[1, 0])(O)
# pred = TimeDistributed( Dense(61, activation='softmax', kernel_regularizer=l2(d.l2), use_bias=True, bias_initializer="zeros", kernel_initializer='random_uniform' ))(O)
pred = TimeDistributed(
Dense(61,
kernel_regularizer=l2(d.l2),
use_bias=True,
bias_initializer="zeros",
kernel_initializer='random_uniform'))(O)
output = Activation('softmax', name='softmax')(pred)
network = CTCModel([I], [output])
# network.compile(Adam(lr=0.0001))
""" CTC Loss - Implemented differently
if d.ctc:
# CTC For sequence labelling
O = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([pred, labels,input_length,label_length])
# Creating a function for testing and validation purpose
val_function = K.function([I],[pred])
# Return the model
return Model(inputs=[I, input_length, labels, label_length], outputs=O), val_function
"""
# return Model(inputs=I, outputs=pred)
return network
def line_lstm_ctc(input_shape, output_shape, window_width=28, window_stride=14):
image_height, image_width = input_shape
output_length, num_classes = output_shape
num_windows = int((image_width - window_width) / window_stride) + 1
if num_windows < output_length:
raise ValueError(f'Window width/stride need to generate at least {output_length} windows (currently {num_windows})')
image_input = Input(shape=input_shape, name='image')
y_true = Input(shape=(output_length,), name='y_true')
input_length = Input(shape=(1,), name='input_length')
label_length = Input(shape=(1,), name='label_length')
gpu_present = len(device_lib.list_local_devices()) > 1
lstm_fn = CuDNNLSTM if gpu_present else LSTM
# Your code should use slide_window and extract image patches from image_input.
# Pass a convolutional model over each image patch to generate a feature vector per window.
# Pass these features through one or more LSTM layers.
# Convert the lstm outputs to softmax outputs.
# Note that lstms expect a input of shape (num_batch_size, num_timesteps, feature_length).
##### Your code below (Lab 3)
image_reshaped = Reshape((image_height, image_width, 1))(image_input)
# (image_height, image_width, 1)
image_patches = Lambda(
slide_window,
arguments={'window_width': window_width, 'window_stride': window_stride}
)(image_reshaped)
# (num_windows, image_height, window_width, 1)
# Make a LeNet and get rid of the last two layers (softmax and dropout)
convnet = lenet((image_height, window_width, 1), (num_classes,))
convnet = KerasModel(inputs=convnet.inputs, outputs=convnet.layers[-2].output)
convnet_outputs = TimeDistributed(convnet)(image_patches)
# (num_windows, 128)
lstm_output1 = lstm_fn(128, return_sequences=True)(convnet_outputs)
lstm_output = lstm_fn(64, return_sequences=True)(lstm_output1)
# (num_windows, 128)
softmax_output = Dense(num_classes, activation='softmax', name='softmax_output')(lstm_output)
# (num_windows, num_classes)
##### Your code above (Lab 3)
input_length_processed = Lambda(
lambda x, num_windows=None: x * num_windows,
arguments={'num_windows': num_windows}
)(input_length)
ctc_loss_output = Lambda(
lambda x: K.ctc_batch_cost(x[0], x[1], x[2], x[3]),
name='ctc_loss'
)([y_true, softmax_output, input_length_processed, label_length])
ctc_decoded_output = Lambda(
lambda x: ctc_decode(x[0], x[1], output_length),
name='ctc_decoded'
)([softmax_output, input_length_processed])
model = KerasModel(
inputs=[image_input, y_true, input_length, label_length],
outputs=[ctc_loss_output, ctc_decoded_output]
)
return model
# One-hot encoding
x = utils.to_categorical(x, num_classes=num_classes)
# reshape X to be [samples, time steps, features]
x = np.reshape(x, (-1, len(x), data_dim))
print(x.shape)
# One-hot encoding
y = utils.to_categorical(y, num_classes=num_classes)
# time steps
y = np.reshape(y, (-1, len(y), data_dim))
print(y.shape)
model = Sequential()
model.add(LSTM(128, input_shape=(
timesteps, data_dim), return_sequences=True))
model.add(TimeDistributed(Dense(num_classes,activation='softmax')))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop', metrics=['accuracy'])
history=model.fit(x, y, epochs=100, verbose=2)
predictions = model.predict(x, verbose=2)
for i, prediction in enumerate(predictions):
print(prediction)
x_index = np.argmax(x[i], axis=1)
x_str = [char_set[j] for j in x_index]
print(x_index, ''.join(x_str))
index = np.argmax(prediction, axis=1)
def build_model(self, predict, custom_batch_size=None):
conf = self.conf
model_conf = conf['model']
rnn_size = model_conf['rnn_size']
rnn_type = model_conf['rnn_type']
regularization = model_conf['regularization']
dense_regularization = model_conf['dense_regularization']
use_batch_norm = False
if 'use_batch_norm' in model_conf:
use_batch_norm = model_conf['use_batch_norm']
dropout_prob = model_conf['dropout_prob']
length = model_conf['length']
pred_length = model_conf['pred_length']
# skip = model_conf['skip']
stateful = model_conf['stateful']
return_sequences = model_conf['return_sequences']
# model_conf['output_activation']
output_activation = conf['data']['target'].activation
use_signals = conf['paths']['use_signals']
num_signals = sum([sig.num_channels for sig in use_signals])
num_conv_filters = model_conf['num_conv_filters']
# num_conv_layers = model_conf['num_conv_layers']
size_conv_filters = model_conf['size_conv_filters']
pool_size = model_conf['pool_size']
dense_size = model_conf['dense_size']
batch_size = self.conf['training']['batch_size']
if predict:
batch_size = self.conf['model']['pred_batch_size']
# so we can predict with one time point at a time!
if return_sequences:
length = pred_length
else:
length = 1
if custom_batch_size is not None:
batch_size = custom_batch_size
if rnn_type == 'LSTM':
rnn_model = LSTM
elif rnn_type == 'CuDNNLSTM':
rnn_model = CuDNNLSTM
elif rnn_type == 'SimpleRNN':
rnn_model = SimpleRNN
else:
print('Unkown Model Type, exiting.')
exit(1)
batch_input_shape = (batch_size, length, num_signals)
# batch_shape_non_temporal = (batch_size, num_signals)
indices_0d, indices_1d, num_0D, num_1D = self.get_0D_1D_indices()
def slicer(x, indices):
return x[:, indices]
def slicer_output_shape(input_shape, indices):
shape_curr = list(input_shape)
assert len(shape_curr) == 2 # only valid for 3D tensors
shape_curr[-1] = len(indices)
return tuple(shape_curr)
pre_rnn_input = Input(shape=(num_signals, ))
if num_1D > 0:
pre_rnn_1D = Lambda(
lambda x: x[:, len(indices_0d):],
output_shape=(len(indices_1d), ))(pre_rnn_input)
pre_rnn_0D = Lambda(
lambda x: x[:, :len(indices_0d)],
output_shape=(len(indices_0d), ))(pre_rnn_input)
# slicer(x,indices_0d),lambda s:
# slicer_output_shape(s,indices_0d))(pre_rnn_input)
pre_rnn_1D = Reshape(
(num_1D, len(indices_1d) // num_1D))(pre_rnn_1D)
pre_rnn_1D = Permute((2, 1))(pre_rnn_1D)
if ('simple_conv' in model_conf.keys()
and model_conf['simple_conv'] is True):
for i in range(model_conf['num_conv_layers']):
pre_rnn_1D = Convolution1D(num_conv_filters,
size_conv_filters,
padding='valid',
activation='relu')(pre_rnn_1D)
pre_rnn_1D = MaxPooling1D(pool_size)(pre_rnn_1D)
else:
for i in range(model_conf['num_conv_layers']):
div_fac = 2**i
'''The first conv layer learns `num_conv_filters//div_fac`
filters (aka kernels), each of size
`(size_conv_filters, num1D)`. Its output will have shape
(None, len(indices_1d)//num_1D - size_conv_filters + 1,
num_conv_filters//div_fac), i.e., for
each position in the input spatial series (direction along
radius), the activation of each filter at that position.
'''
'''For i=1 first conv layer would get:
(None, (len(indices_1d)//num_1D - size_conv_filters
+ 1)/pool_size-size_conv_filters + 1,
num_conv_filters//div_fac)
'''
pre_rnn_1D = Convolution1D(num_conv_filters // div_fac,
size_conv_filters,
padding='valid')(pre_rnn_1D)
if use_batch_norm:
pre_rnn_1D = BatchNormalization()(pre_rnn_1D)
pre_rnn_1D = Activation('relu')(pre_rnn_1D)
'''The output of the second conv layer will have shape
(None, len(indices_1d)//num_1D - size_conv_filters + 1,
num_conv_filters//div_fac),
i.e., for each position in the input spatial series
(direction along radius), the activation of each filter
at that position.
For i=1, the second layer would output
(None, (len(indices_1d)//num_1D - size_conv_filters + 1)/
pool_size-size_conv_filters + 1,num_conv_filters//div_fac)
'''
pre_rnn_1D = Convolution1D(num_conv_filters // div_fac,
1,
padding='valid')(pre_rnn_1D)
if use_batch_norm:
pre_rnn_1D = BatchNormalization()(pre_rnn_1D)
pre_rnn_1D = Activation('relu')(pre_rnn_1D)
'''Outputs (None, (len(indices_1d)//num_1D - size_conv_filters
+ 1)/pool_size, num_conv_filters//div_fac)
For i=1, the pooling layer would output:
(None,((len(indices_1d)//num_1D- size_conv_filters
+ 1)/pool_size-size_conv_filters+1)/pool_size,
num_conv_filters//div_fac)
'''
pre_rnn_1D = MaxPooling1D(pool_size)(pre_rnn_1D)
pre_rnn_1D = Flatten()(pre_rnn_1D)
pre_rnn_1D = Dense(
dense_size,
kernel_regularizer=l2(dense_regularization),
bias_regularizer=l2(dense_regularization),
activity_regularizer=l2(dense_regularization))(pre_rnn_1D)
if use_batch_norm:
pre_rnn_1D = BatchNormalization()(pre_rnn_1D)
pre_rnn_1D = Activation('relu')(pre_rnn_1D)
pre_rnn_1D = Dense(
dense_size // 4,
kernel_regularizer=l2(dense_regularization),
bias_regularizer=l2(dense_regularization),
activity_regularizer=l2(dense_regularization))(pre_rnn_1D)
if use_batch_norm:
pre_rnn_1D = BatchNormalization()(pre_rnn_1D)
pre_rnn_1D = Activation('relu')(pre_rnn_1D)
pre_rnn = Concatenate()([pre_rnn_0D, pre_rnn_1D])
else:
pre_rnn = pre_rnn_input
if model_conf['rnn_layers'] == 0 or (
'extra_dense_input' in model_conf.keys()
and model_conf['extra_dense_input']):
pre_rnn = Dense(
dense_size,
activation='relu',
kernel_regularizer=l2(dense_regularization),
bias_regularizer=l2(dense_regularization),
activity_regularizer=l2(dense_regularization))(pre_rnn)
pre_rnn = Dense(
dense_size // 2,
activation='relu',
kernel_regularizer=l2(dense_regularization),
bias_regularizer=l2(dense_regularization),
activity_regularizer=l2(dense_regularization))(pre_rnn)
pre_rnn = Dense(
dense_size // 4,
activation='relu',
kernel_regularizer=l2(dense_regularization),
bias_regularizer=l2(dense_regularization),
activity_regularizer=l2(dense_regularization))(pre_rnn)
pre_rnn_model = tf.keras.Model(inputs=pre_rnn_input, outputs=pre_rnn)
# TODO(KGF): uncomment following lines to get summary of pre-RNN model
# from mpi4py import MPI
# comm = MPI.COMM_WORLD
# task_index = comm.Get_rank()
# if not predict and task_index == 0:
# print('Printing out pre_rnn model...')
# fr = open('model_architecture.log', 'w')
# ori = sys.stdout
# sys.stdout = fr
# pre_rnn_model.summary()
# sys.stdout = ori
# fr.close()
# pre_rnn_model.summary()
x_input = Input(batch_shape=batch_input_shape)
# TODO(KGF): Ge moved this inside a new conditional in Dec 2019. check
# x_in = TimeDistributed(pre_rnn_model)(x_input)
if (num_1D > 0 or ('extra_dense_input' in model_conf.keys()
and model_conf['extra_dense_input'])):
x_in = TimeDistributed(pre_rnn_model)(x_input)
else:
x_in = x_input
# ==========
# TCN MODEL
# ==========
if ('keras_tcn' in model_conf.keys()
and model_conf['keras_tcn'] is True):
print('Building TCN model....')
tcn_layers = model_conf['tcn_layers']
tcn_dropout = model_conf['tcn_dropout']
nb_filters = model_conf['tcn_hidden']
kernel_size = model_conf['kernel_size_temporal']
nb_stacks = model_conf['tcn_nbstacks']
use_skip_connections = model_conf['tcn_skip_connect']
activation = model_conf['tcn_activation']
use_batch_norm = model_conf['tcn_batch_norm']
for _ in range(model_conf['tcn_pack_layers']):
x_in = TCN(use_batch_norm=use_batch_norm,
activation=activation,
use_skip_connections=use_skip_connections,
nb_stacks=nb_stacks,
kernel_size=kernel_size,
nb_filters=nb_filters,
num_layers=tcn_layers,
dropout_rate=tcn_dropout)(x_in)
x_in = Dropout(dropout_prob)(x_in)
else: # end TCN model
# ==========
# RNN MODEL
# ==========
# LSTM in ONNX: "The maximum opset needed by this model is only 9."
model_kwargs = dict(
return_sequences=return_sequences,
# batch_input_shape=batch_input_shape,
stateful=stateful,
kernel_regularizer=l2(regularization),
recurrent_regularizer=l2(regularization),
bias_regularizer=l2(regularization),
)
if rnn_type != 'CuDNNLSTM':
# Dropout is unsupported in CuDNN library
model_kwargs['dropout'] = dropout_prob
model_kwargs['recurrent_dropout'] = dropout_prob
for _ in range(model_conf['rnn_layers']):
x_in = rnn_model(rnn_size, **model_kwargs)(x_in)
x_in = Dropout(dropout_prob)(x_in)
if return_sequences:
# x_out = TimeDistributed(Dense(100,activation='tanh')) (x_in)
x_out = TimeDistributed(Dense(
1, activation=output_activation))(x_in)
model = tf.keras.Model(inputs=x_input, outputs=x_out)
# bug with tensorflow/Keras
# TODO(KGF): what is this bug? this is the only direct "tensorflow"
# import outside of mpi_runner.py and runner.py
# if (conf['model']['backend'] == 'tf'
# or conf['model']['backend'] == 'tensorflow'):
# first_time = "tensorflow" not in sys.modules
# import tensorflow as tf
# if first_time:
# tf.compat.v1.keras.backend.get_session().run(
# tf.global_variables_initializer())
model.reset_states()
return model
state_h = Concatenate()([forward_h, backward_h])
state_c = Concatenate()([forward_c, backward_c])
# Set up the decoder, using `encoder_states` as initial state
encoder_states = [state_h, state_c]
decoder_inputs = Input(shape=(None, ), name="Decoder_Input")
dec_emb = Embedding(num_decoder_tokens, latent_dim)(decoder_inputs)
decoder_lstm = LSTM(latent_dim * 2,
return_sequences=True,
return_state=True,
name="Decoder_LSTM")
decoder_outputs, _, _ = decoder_lstm(dec_emb, initial_state=encoder_states)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = TimeDistributed(decoder_dense)(decoder_outputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
train_samples = len(X_train)
val_samples = len(X_test)
batch_size = 128
epochs = 5
model.fit(generate_batch(X_train, y_train, batch_size=batch_size),
emb = Embedding( input_dim=VOCAB_SIZE, output_dim=50, weights=[embedding_matrix],
trainable=False, input_length=MAX_SEQ_LEN)(inp)
embedding = Model( inp, emb )
save_model( embedding, "embedding_model.h5" )
#Model for identifying tags of each word
inp = Input( shape=(MAX_SEQ_LEN, 50) )
drop = Dropout(0.1)(inp)
#two bidirectinal LSTM layers
lstm1 = LSTM( 30, return_sequences=True, recurrent_dropout=0.1)
seq1 = Bidirectional(lstm1)( drop )
lstm2 = LSTM( 30, return_sequences=True, recurrent_dropout=0.1)
seq2 = Bidirectional(lstm2)( seq1 )
# TIME_DISTRIBUTED -> ( MAX_SEQ_LEN, 50 ) -> (MAX_SEQ_LEN, NER_SIZE)
tags = TimeDistributed( Dense(NER_SIZE, activation="relu") )(seq2)
model = Model( inp, tags )
model.compile( optimizer="rmsprop", loss="categorical_crossentropy", metrics=[ "accuracy" ] )
#batch generator for model training
def getBatch(sentences, targets, batch_size=128):
n = len(sentences)//batch_size
for i in range( n+1 ):
x = sentences[ i*batch_size : (i+1)*batch_size ]
x = embedding.predict(x)
y = targets[ i*batch_size : (i+1)*batch_size ]
yield x,y
#do training
all_metrics = []
for epoch in range(1,51):
# Import Dense and TimeDistributed layers
from tensorflow.keras.layers import Dense, TimeDistributed
# Define a softmax dense layer that has fr_vocab outputs
de_dense = Dense(fr_vocab, activation='softmax')
# Wrap the dense layer in a TimeDistributed layer
de_dense_time = TimeDistributed(de_dense)
# Get the final prediction of the model
de_pred = de_dense_time(de_out)
print("Prediction shape: ", de_pred.shape)
def create_model_lstm(data_type,
cnn=False,
layer_nb=5,
classes=len(labels),
lstm_nodes=64,
learning_rate=0.0001):
if data_type == 'mfcc':
input_shape = (98, 13) if not cnn else (98, 13, 1)
if data_type == 'ssc':
input_shape = (98, 26) if not cnn else (98, 26, 1)
model = Sequential(name='lstm_{}'.format('' if not cnn else 'cnn_') +
data_type)
model.add(Input(shape=input_shape))
if cnn:
cnn = Sequential(name='cnn_entry_' + data_type)
cnn.add(Conv1D(22, 3, padding='same', name='conv1'))
cnn.add(BatchNormalization(name='batch_norm1'))
cnn.add(tf.keras.layers.Activation('relu'))
cnn.add(Conv1D(44, 3, padding='same', name='conv2'))
cnn.add(BatchNormalization(name='batch_norm2'))
cnn.add(tf.keras.layers.Activation('relu'))
cnn.add(Conv1D(22, 3, padding='same', name='conv3'))
cnn.add(BatchNormalization(name='batch_norm3'))
cnn.add(tf.keras.layers.Activation('relu'))
cnn.add(AveragePooling1D(2, strides=2, name='pooling'))
model.add(TimeDistributed(cnn))
model.add(Reshape((98, -1)))
if layer_nb == 1:
model.add(LSTM(lstm_nodes, name='lstm_entry'))
model.add(Lambda(lambda x: K.l2_normalize(x, axis=1)))
model.add(BatchNormalization(name='block1_batchnorm'))
else:
model.add(LSTM(lstm_nodes, return_sequences=True, name='lstm_entry'))
model.add(Lambda(lambda x: K.l2_normalize(x, axis=1)))
model.add(BatchNormalization(name='block1_batchnorm'))
for i in range(2, layer_nb):
model.add(
LSTM(lstm_nodes,
return_sequences=True,
name='lstm_{}'.format(i)))
model.add(Lambda(lambda x: K.l2_normalize(x, axis=1)))
model.add(
BatchNormalization(name='block{}_batchnorm'.format(str(i))))
model.add(LSTM(lstm_nodes, name='lstm_out'))
model.add(Lambda(lambda x: K.l2_normalize(x, axis=1)))
model.add(BatchNormalization(name='blockout_batchnorm'))
model.add(Flatten())
model.add(Dense(classes, activation='softmax', name='predictions'))
optimizer = RMSprop(lr=learning_rate)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
model.summary()
return model
# LSTM 입력을 위해 3차원 텐서 형태로 변경
X = X.reshape(1, n_timesteps, 1)
y = y.reshape(1, n_timesteps, 1)
return X, y
# 하이퍼파라미터 정의
n_units = 20
n_timesteps = 4
# 양방향 LSTM 모델 정의
model = Sequential()
model.add(
Bidirectional(
LSTM(n_units, return_sequences=True, input_shape=(n_timesteps, 1))))
model.add(TimeDistributed(Dense(1, activation='sigmoid')))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# 모델 학습
# 에포크마다 학습 데이터를 생성해서 학습
for epoch in range(1000):
X, y = get_sequence(n_timesteps)
model.fit(X, y, epochs=1, batch_size=1, verbose=2)
# 모델 평가
X, y = get_sequence(n_timesteps)
yhat = model.predict(X, verbose=0)
yhat2 = np.argmax(yhat, axis=1)
print(yhat2)
state_c = Concatenate()([forward_c3,backward_c3]) decoder_inputs = Input(shape=(None,)) dec_emb_layer = Embedding(y_voc_size, latent_dim,trainable=True) dec_emb = dec_emb_layer(decoder_inputs) decoder_lstm = LSTM(600, return_sequences=True, return_state=True) decoder_outputs,decoder_fwd_state, decoder_back_state = decoder_lstm(dec_emb,initial_state=[state_h, state_c]) attn_layer = AttentionLayer(name='attention_layer') attn_out, attn_states = attn_layer([encoder_outputs, decoder_outputs]) decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([decoder_outputs, attn_out]) decoder_dense = TimeDistributed(Dense(y_voc_size, activation='softmax')) decoder_out = decoder_dense(decoder_concat_input) model = Model([encoder_inputs, decoder_inputs], decoder_out) model.summary() model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',metrics=['accuracy']) es = EarlyStopping(monitor='val_loss', mode='min') history=model.fit([x_tr,y_tr[:,:-1]], y_tr.reshape(y_tr.shape[0],y_tr.shape[1], 1)[:,1:] ,epochs=50,callbacks=[es],batch_size=128, validation_data=([x_val,y_val[:,:-1]], y_val.reshape(y_val.shape[0],y_val.shape[1], 1)[:,1:])) from matplotlib import pyplot pyplot.plot(history.history['loss'], label='train') pyplot.plot(history.history['val_loss'], label='test') pyplot.legend() pyplot.show()
def init_nslr_model(preprocess_size, lrs_size, lrs_levels, preprocess='conv', preprocess_time=False, lrs_diff=True, lrs_time=True, recursive_tensors=True, name_only=False, input_shape=None, num_classes=None, lrs_norm='BN'):
preprocess = preprocess.lower()
if preprocess != 'conv' and preprocess != 'dense':
preprocess_name = ''
else:
preprocess_name = 'Conv' if preprocess == 'conv' else 'Dense'
preprocess_name = 'T{}'.format(preprocess_name) if preprocess_time else preprocess_name
lrs_time_tag = 'T' if lrs_time else ''
lrs_diff_tag = 'D' if lrs_diff else ''
lrs_recurrent_tag = 'R' if recursive_tensors else ''
lrs_name = '{}{}{}LRS{}'.format(lrs_time_tag, lrs_diff_tag, lrs_recurrent_tag, lrs_norm)
model_name = '{}{}_H{}_W{}'.format(preprocess_name, lrs_name, preprocess_size, lrs_size)
if name_only: return model_name
num_sig_layers = 3
model = Sequential()
model.add(InputLayer(input_shape=input_shape))
if preprocess_name != '':
if preprocess_time:
model.add(Time())
if preprocess == 'conv':
model.add(Conv1D(preprocess_size, 8, padding='same', kernel_initializer='he_uniform'))
else:
model.add(TimeDistributed(Dense(preprocess_size, kernel_initializer='he_uniform')))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
if preprocess_time:
model.add(Time())
if preprocess == 'conv':
model.add(Conv1D(preprocess_size, 5, padding='same' , kernel_initializer='he_uniform'))
else:
model.add(TimeDistributed(Dense(preprocess_size, kernel_initializer='he_uniform')))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
if preprocess_time:
model.add(Time())
if preprocess == 'conv':
model.add(Conv1D(preprocess_size, 3, padding='same', kernel_initializer='he_uniform'))
else:
model.add(Dense(preprocess_size, kernel_initializer='he_uniform'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
for i in range(num_sig_layers-1):
# model.add(Conv1D(conv_size, 3, padding='same', kernel_initializer='he_uniform'))
# model.add(BatchNormalization(axis=-1))
if lrs_time:
model.add(Time())
if lrs_diff:
model.add(Difference())
model.add(LRS(lrs_size, lrs_levels, return_sequences=True, recursive_tensors=recursive_tensors))
model.add(Reshape((input_shape[0]-i-1, lrs_levels, lrs_size,)))
if lrs_norm == 'BN':
model.add(BatchNormalization(axis=[-2]))
elif lrs_norm == 'TBN':
model.add(BatchNormalization(axis=[-2, -1]))
elif lrs_norm == 'LN':
model.add(LayerNormalization(axis=[-3, -1]))
# model.add(LayerNormalization(axis=[1, 3]))
#model.add(LayerNormalization(axis=[1, 3]))
model.add(Reshape((input_shape[0]-i-1, lrs_levels * lrs_size,)))
# model.add(Activation('relu'))
# if renorm:
# model.add(BatchNormalization(axis=[1, 2], renorm=True, center=False, scale=False))
# else:
#
# model.add(Conv1D(conv_size, 3, padding='same', kernel_initializer='he_uniform'))
# model.add(BatchNormalization(axis=-1))
if lrs_time:
model.add(Time())
if lrs_diff:
model.add(Difference())
model.add(LRS(lrs_size, lrs_levels, return_sequences=False, recursive_tensors=recursive_tensors))
# model.add(BatchNormalization(axis=1, center=False, scale=False))
model.add(Reshape((lrs_levels, lrs_size,)))
# model.add(LayerNormalization(axis=[2]))
model.add(BatchNormalization(axis=1))
model.add(Reshape((lrs_levels * lrs_size,)))
# model.add(BatchNormalization(axis=-1, renorm=renorm, center=False, scale=False))
# model.add(tf.keras.layers.Dropout(0.5))
# if gap:
# model.add(GlobalAveragePooling1D())
# else:
# model.add(Lambda(lambda X: X[:, -1]))
model.add(Dense(num_classes, activation='softmax'))
model._name = model_name
return model
def sequential_cnn_2D(args):
#
# Model parameters
#
model_type = args.model_type
# input_shape = args.input_shape
n_convs = args.n_layers_convs
n_dense = args.n_layers_dense
# max_str_len = args.max_str_len
num_classes = args.num_classes
activation = args.act
advanced_act = args.aact
padding = args.padding
start_filter = args.sf_dim
kernel_size = args.kernel_size
kernel_init = args.kernel_init
l2_reg = args.l2_reg
shared_axes = args.shared_axes
opt = args.opt
#
# Layer parameters
#
# Conv layers parameters
convArgs = {
"activation": activation,
"data_format": "channels_last",
"padding": padding,
"bias_initializer": "zeros",
"kernel_regularizer": l2(l2_reg),
"kernel_initializer": kernel_init,
"use_bias": True
}
# Dense layers parameters
denseArgs = {
"activation": activation,
"kernel_regularizer": l2(l2_reg),
"kernel_initializer": kernel_init, # "glorot_normal"
"bias_initializer": "zeros",
"use_bias": True
}
#
# Model building
#
if model_type == "quaternion":
quat_init = 'quaternion'
convArgs.update({"kernel_initializer": quat_init})
# input_data = Input(name='the_input', shape=input_shape, dtype='float64')
model = Sequential()
# Convolutional Stage
if model_type == 'real':
# batch-normalization
# O = BatchNormalization(axis=-1, momentum=0.99, epsilon=1e-3, center=True, scale=True)
for idx in range(n_convs):
conv_filters = start_filter * (2**idx)
O = Conv2D(conv_filters,
kernel_size,
name='conv_{}'.format(idx),
**convArgs)
model.add(O)
if advanced_act == 'prelu':
O = PReLU()
model.add(O)
# batch-normalization
O = BatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)
model.add(O)
else:
# batch-normalization
# O = QuaternionBatchNormalization(axis=-1, momentum=0.99, epsilon=1e-3, center=True, scale=True)
for idx in range(n_convs):
conv_filters = start_filter * (2**idx)
O = QuaternionConv2D(conv_filters,
kernel_size,
name='conv_{}'.format(idx),
**convArgs)(O)
if advanced_act == 'prelu':
O = PReLU()
model.add(O)
# batch-normalization
O = QuaternionBatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
# conv_shape = O.shape
#
# Reshaping Stage
#
O = Reshape(target_shape=[
K.int_shape(O)[1],
K.int_shape(O)[2] * K.int_shape(O)[3]
])(O)
# Fully-Connected Stage
if model_type == 'real':
for idx in range(n_dense):
O = TimeDistributed(Dense(1024, **denseArgs))
model.add(O)
if advanced_act == 'prelu':
O = PReLU()
model.add(O)
# batch-normalization
O = BatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)
model.add(O)
else:
for idx in range(n_dense):
O = TimeDistributed(QuaternionDense(1024, **denseArgs))
model.add(O)
if advanced_act == 'prelu':
O = PReLU()
model.add(O)
# batch-normalization
O = QuaternionBatchNormalization(axis=-1,
momentum=0.99,
epsilon=1e-3,
center=True,
scale=True)(O)
#
# Prediction (Output) Stage
#
y_pred = Dense(num_classes,
activation='softmax',
kernel_regularizer=l2(l2_reg),
use_bias=True,
bias_initializer="zeros",
kernel_initializer=kernel_init)
model.add(y_pred)
# clipnorm seems to speeds up convergence
opt_dict = {
'sgd': SGD(lr=0.02,
decay=1e-6,
momentum=0.9,
nesterov=True,
clipnorm=5),
'adam': Adam(lr=0.02, clipnorm=5)
}
optimizer = opt_dict[opt]
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss='categorical_crossentropy', optimizer=optimizer)
return model
x_train, x_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=1)
from tensorflow.keras import Model, Input
from tensorflow.keras.layers import LSTM, Embedding, Dense
from tensorflow.keras.layers import TimeDistributed, SpatialDropout1D, Bidirectional
input_word = Input(shape=(max_len, ))
model = Embedding(input_dim=num_words, output_dim=50,
input_length=max_len)(input_word)
model = SpatialDropout1D(0.1)(model)
model = Bidirectional(
LSTM(units=100, return_sequences=True, recurrent_dropout=0.1))(model)
out = TimeDistributed(Dense(num_tags, activation="softmax"))(model)
model = Model(input_word, out)
model.summary()
model.compile(optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from livelossplot.tf_keras import PlotLossesCallback
chkpt = ModelCheckpoint("model_weights.h5",
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True,
batch_size=384)
y_in = Input(shape=(512, 1))
y_err = Input(shape=(512, 1))
# h_enc = Conv1D(32, 2, activation='relu')(y_in)
# h_enc = Conv1D(32, 8, activation='relu')(h_enc)
# h_enc = CuDNNGRU(512, return_sequences=True)(y_in)
# h_enc = CuDNNGRU(256, return_sequences=True)(h_enc)
h_enc = CuDNNGRU(64, return_sequences=False)(y_in)
# h_enc = BatchNormalization()(h_enc)
h_enc = Dense(32, activation=None, name='bottleneck')(h_enc)
# h_enc = BatchNormalization()(h_enc)
h_dec = RepeatVector(512)(h_enc)
h_dec = CuDNNGRU(64, return_sequences=True)(h_dec)
# h_dec = CuDNNGRU(256, return_sequences=True)(h_dec)
h_dec = TimeDistributed(Dense(1))(h_dec)
model = Model(inputs=[y_in, y_err], outputs=h_dec)
model.compile(optimizer=Adam(clipvalue=0.5), loss=chi2(y_err))
# model.load_weights("model_weights/lstm_autoencoder_2020-01-09_18-20-21.h5")
training_time_stamp = datetime.datetime.now(
tz=pytz.timezone('Europe/London')).strftime("%Y-%m-%d_%H-%M-%S")
CB = EarlyStopping(monitor='val_loss',
min_delta=1e-5,
patience=100,
verbose=1,
mode='auto')
MC = ModelCheckpoint('model_weights/model_{}.h5'.format(training_time_stamp),
monitor='val_loss',
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x_padded, y_padded, test_size = 0.1)
"""**BUILD AND TRAIN THE MODEL**"""
# Sequential Model
model = Sequential()
# embedding layer
model.add(Embedding(english_vocab_size, 256, input_length = maxlen_english, mask_zero = True))
# encoder
model.add(LSTM(256))
# decoder
model.add(RepeatVector(maxlen_french))
model.add(LSTM(256, return_sequences= True ))
model.add(TimeDistributed(Dense(french_vocab_size, activation ='softmax')))
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
# change the shape of target from 2D to 3D
y_train = np.expand_dims(y_train, axis = 2)
y_train.shape
model.fit(x_train, y_train, batch_size=1024, validation_split= 0.1, epochs=20)
"""**Got 92.5 % accuracy for 20 epoch :)**"""
# save the model
model.save("weights.h5")
"""**ASSESS TRAINED MODEL PERFORMANCE**"""
