def SLFNN(vst_onlyTokens,
dl_terms,
dl_associations,
vso,
nbEpochs=100,
batchSize=64):
vstTerm, l_unknownToken = word2term.wordVST2TermVST(
vst_onlyTokens, dl_terms)
data, labels = getMatrix(dl_terms,
vstTerm,
dl_associations,
vso,
symbol="___")
inputSize = data.shape[1]
ontoSpaceSize = labels.shape[1]
model = models.Sequential()
model.add(
layers.Dense(units=ontoSpaceSize,
use_bias=True,
kernel_initializer=initializers.GlorotUniform(),
input_shape=(inputSize, )))
model.summary()
model.compile(
optimizer=optimizers.Nadam(),
loss=losses.LogCosh(),
metrics=[metrics.CosineSimilarity(),
metrics.MeanSquaredError()])
model.fit(data, labels, epochs=nbEpochs, batch_size=batchSize)
return model, vso, l_unknownToken
def SCNN(vst_onlyTokens,
dl_terms,
dl_associations,
vso,
nbEpochs=150,
batchSize=64,
l_numberOfFilters=[4000],
l_filterSizes=[1],
phraseMaxSize=15):
data, labels, l_unkownTokens, l_uncompleteExpressions = prepare2D_data(
vst_onlyTokens, dl_terms, dl_associations, vso, phraseMaxSize)
embeddingSize = data.shape[2]
ontoSpaceSize = labels.shape[2]
inputLayer = Input(shape=(phraseMaxSize, embeddingSize))
l_subLayers = list()
for i, filterSize in enumerate(l_filterSizes):
convLayer = (layers.Conv1D(
l_numberOfFilters[i],
filterSize,
strides=1,
kernel_initializer=initializers.GlorotUniform()))(inputLayer)
outputSize = phraseMaxSize - filterSize + 1
pool = (layers.MaxPool1D(pool_size=outputSize))(convLayer)
activationLayer = (layers.LeakyReLU(alpha=0.3))(pool)
l_subLayers.append(activationLayer)
if len(l_filterSizes) > 1:
concatenateLayer = (layers.Concatenate(axis=-1))(
l_subLayers) # axis=-1 // concatenating on the last dimension
else:
concatenateLayer = l_subLayers[0]
convModel = Model(inputs=inputLayer, outputs=concatenateLayer)
fullmodel = models.Sequential()
fullmodel.add(convModel)
fullmodel.add(
layers.Dense(ontoSpaceSize,
kernel_initializer=initializers.GlorotUniform()))
fullmodel.summary()
fullmodel.compile(
optimizer=optimizers.Nadam(),
loss=losses.LogCosh(),
metrics=[metrics.CosineSimilarity(),
metrics.MeanSquaredError()])
fullmodel.fit(data, labels, epochs=nbEpochs, batch_size=batchSize)
return fullmodel, vso, l_unkownTokens
def train(
label: Label = Label.title,
name: Model = Model.vit32,
num_layers: int = 3,
epochs: int = 5,
dropout_prob: float = 0.4,
batch_size: int = TEST_EXAMPLES,
):
log_dir = LOG_PATH.format(
model=name.name,
label=label.name,
num_layers=num_layers,
dropout_prob=dropout_prob,
)
model_dir = MODEL_PATH.format(
model=name.name,
label=label.name,
num_layers=num_layers,
dropout_prob=dropout_prob,
)
if path.exists(log_dir):
rmtree(log_dir, ignore_errors=True)
if path.exists(model_dir):
rmtree(model_dir, ignore_errors=True)
data = prepare(model=name, label=label)
model = Sequential()
model.add(layers.Flatten())
for l in range(num_layers):
model.add(layers.Dense(SIZE[name]))
model.add(layers.Activation(activations.relu))
model.add(layers.Dropout(dropout_prob))
model.add(layers.Dense(SIZE[name]))
model.compile(
loss=losses.cosine_similarity,
metrics=[metrics.CosineSimilarity()],
optimizer=optimizers.Adam(),
)
training = model.fit(
x=data.X_train,
y=data.Y_train,
batch_size=batch_size,
callbacks=[callbacks.TensorBoard(
log_dir=log_dir,
histogram_freq=1,
)],
epochs=epochs,
validation_data=(data.X_dev, data.Y_dev),
)
results = model.evaluate(data.X_test, data.Y_test, batch_size=batch_size)
model.save(model_dir)
def __get_metric(self, metric):
if metric == "auc":
return m.AUC()
elif metric == "accuracy":
return m.Accuracy()
elif metric == "binary_accuracy":
return m.BinaryAccuracy()
elif metric == "categorical_accuracy":
return m.CategoricalAccuracy()
elif metric == "binary_crossentropy":
return m.BinaryCrossentropy()
elif metric == "categorical_crossentropy":
return m.CategoricalCrossentropy()
elif metric == "sparse_categorical_crossentropy":
return m.SparseCategoricalCrossentropy()
elif metric == "kl_divergence":
return m.KLDivergence()
elif metric == "poisson":
return m.Poission()
elif metric == "mse":
return m.MeanSquaredError()
elif metric == "rmse":
return m.RootMeanSquaredError()
elif metric == "mae":
return m.MeanAbsoluteError()
elif metric == "mean_absolute_percentage_error":
return m.MeanAbsolutePercentageError()
elif metric == "mean_squared_logarithm_error":
return m.MeanSquaredLogarithmError()
elif metric == "cosine_similarity":
return m.CosineSimilarity()
elif metric == "log_cosh_error":
return m.LogCoshError()
elif metric == "precision":
return m.Precision()
elif metric == "recall":
return m.Recall()
elif metric == "true_positive":
return m.TruePositives()
elif metric == "true_negative":
return m.TrueNegatives()
elif metric == "false_positive":
return m.FalsePositives()
elif metric == "false_negative":
return m.FalseNegatives()
else:
raise Exception("specified metric not defined")
anchor_embedding, positive_embedding, negative_embedding = (
embedding(resnet.preprocess_input(anchor)),
embedding(resnet.preprocess_input(positive)),
embedding(resnet.preprocess_input(negative)),
)
"""
Finally, we can compute the cosine similarity between the anchor and positive
images and compare it with the similarity between the anchor and the negative
images.
We should expect the similarity between the anchor and positive images to be
larger than the similarity between the anchor and the negative images.
"""
cosine_similarity = metrics.CosineSimilarity()
positive_similarity = cosine_similarity(anchor_embedding, positive_embedding)
print("Positive similarity:", positive_similarity.numpy())
negative_similarity = cosine_similarity(anchor_embedding, negative_embedding)
print("Negative similarity", negative_similarity.numpy())
"""
## Summary
1. The `tf.data` API enables you to build efficient input pipelines for your model. It is
particularly useful if you have a large dataset. You can learn more about `tf.data`
pipelines in [tf.data: Build TensorFlow input pipelines](https://www.tensorflow.org/guide/data).
def CNorm(vst_onlyTokens,
dl_terms,
dl_associations,
vso,
nbEpochs=30,
batchSize=64,
l_numberOfFilters=[4000],
l_filterSizes=[1],
phraseMaxSize=15):
# Preparing data for SLFNN and S-CNN components:
dataSCNN, labels, l_unkownTokens, l_uncompleteExpressions = prepare2D_data(
vst_onlyTokens, dl_terms, dl_associations, vso, phraseMaxSize)
dataSLFNN = numpy.zeros((dataSCNN.shape[0], dataSCNN.shape[2]))
for i in range(dataSCNN.shape[0]):
numberOfToken = 0
for embedding in dataSCNN[i]:
if not numpy.any(embedding):
pass
else:
numberOfToken += 1
dataSLFNN[i] += embedding
if numberOfToken > 0:
dataSLFNN[i] = dataSLFNN[i] / numberOfToken
# Input layers:
inputLP = Input(shape=dataSLFNN.shape[1])
inputCNN = Input(shape=[dataSCNN.shape[1], dataSCNN.shape[2]])
# SLFNN component:
ontoSpaceSize = labels.shape[2]
denseLP = layers.Dense(
units=ontoSpaceSize,
use_bias=True,
kernel_initializer=initializers.GlorotUniform())(inputLP)
modelLP = Model(inputs=inputLP, outputs=denseLP)
# Shallow-CNN component:
l_subLayers = list()
for i, filterSize in enumerate(l_filterSizes):
convLayer = (layers.Conv1D(
l_numberOfFilters[i],
filterSize,
strides=1,
kernel_initializer=initializers.GlorotUniform()))(inputCNN)
outputSize = phraseMaxSize - filterSize + 1
pool = (layers.MaxPool1D(pool_size=outputSize))(convLayer)
activationLayer = (layers.LeakyReLU(alpha=0.3))(pool)
l_subLayers.append(activationLayer)
if len(l_filterSizes) > 1:
concatenateLayer = (layers.Concatenate(axis=-1))(
l_subLayers) # axis=-1 // concatenating on the last dimension
else:
concatenateLayer = l_subLayers[0]
denseLayer = layers.Dense(
ontoSpaceSize,
kernel_initializer=initializers.GlorotUniform())(concatenateLayer)
modelCNN = Model(inputs=inputCNN, outputs=denseLayer)
convModel = Model(inputs=inputCNN, outputs=concatenateLayer)
fullmodel = models.Sequential()
fullmodel.add(convModel)
# Combination of the two components:
combinedLayer = layers.average([modelLP.output, modelCNN.output])
fullModel = Model(inputs=[inputLP, inputCNN], outputs=combinedLayer)
fullModel.summary()
# Compile and train:
fullModel.compile(
optimizer=optimizers.Nadam(),
loss=losses.LogCosh(),
metrics=[metrics.CosineSimilarity(),
metrics.MeanSquaredError()])
fullModel.fit([dataSLFNN, dataSCNN],
labels,
epochs=nbEpochs,
batch_size=batchSize)
return fullModel, vso, l_unkownTokens