Commit 8db16289 authored by Ienco Dino's avatar Ienco Dino
Browse files

Other files

parent 2648ecb9
......@@ -52,42 +52,41 @@ def buildPair(x_train, labels):
return np.stack(f_data, axis=0), np.stack(s_data, axis=0), np.array(y_val)
def trainStepL(model, x_train, labels, loss_object, optimizer, BATCH_SIZE, e):
loss_iteration = 0
tot_loss = 0.0
margin = 1.0
f_data, s_data, y_val = buildPair(x_train, labels)
def trainStepL(model, f_data, s_data, y_val, loss_object, optimizer, BATCH_SIZE, e):
loss_iteration = 0
tot_loss = 0.0
margin = 1.0
f_data, s_data, y_val = shuffle(f_data, s_data, y_val)
iterations = f_data.shape[0] / BATCH_SIZE
if f_data.shape[0] % BATCH_SIZE != 0:
iterations += 1
f_data, s_data, y_val = shuffle(f_data, s_data, y_val)
iterations = f_data.shape[0] / BATCH_SIZE
if f_data.shape[0] % BATCH_SIZE != 0:
iterations += 1
for ibatch in range(int(iterations)):
batch_f = getBatch(f_data, ibatch, BATCH_SIZE)
batch_s = getBatch(s_data, ibatch, BATCH_SIZE)
batch_y = getBatch(y_val, ibatch, BATCH_SIZE)
with tf.GradientTape() as tape:
d_w = model.siameseDistance([batch_f, batch_s], training=True)
equal_loss = (.5* (1-batch_y) * d_w)
neg_loss = (.5* batch_y * tf.math.maximum(0 , margin - d_w) )
for ibatch in range(int(iterations)):
batch_f = getBatch(f_data, ibatch, BATCH_SIZE)
batch_s = getBatch(s_data, ibatch, BATCH_SIZE)
batch_y = getBatch(y_val, ibatch, BATCH_SIZE)
with tf.GradientTape() as tape:
d_w = model.siameseDistance([batch_f, batch_s], training=True)
equal_loss = (.5* (1-batch_y) * d_w)
neg_loss = (.5* batch_y * tf.math.maximum(0 , margin - d_w) )
loss = equal_loss + neg_loss
loss = tf.reduce_mean(loss)
_, reco_f, reco_fR, _ = model(batch_f, training=True)
_, reco_s, reco_sR, _ = model(batch_s, training=True)
loss = equal_loss + neg_loss
loss = tf.reduce_mean(loss)
_, reco_f, reco_fR, _ = model(batch_f, training=True)
_, reco_s, reco_sR, _ = model(batch_s, training=True)
loss+= loss_object(batch_f, reco_f)
loss+= loss_object(batch_f, reco_fR)
loss+= loss_object(batch_f, reco_fR)
loss+= loss_object(batch_s, reco_s)
loss+= loss_object(batch_f, reco_sR)
grads = tape.gradient(loss, model.trainable_variables)
grads = [grad if grad is not None else tf.zeros_like(var) for var, grad in zip(model.trainable_variables, grads)]
optimizer.apply_gradients(zip(grads, model.trainable_variables))
tot_loss+=loss
loss+= loss_object(batch_s, reco_s)
loss+= loss_object(batch_f, reco_sR)
grads = tape.gradient(loss, model.trainable_variables)
grads = [grad if grad is not None else tf.zeros_like(var) for var, grad in zip(model.trainable_variables, grads)]
optimizer.apply_gradients(zip(grads, model.trainable_variables))
tot_loss+=loss
return (tot_loss / iterations)
return (tot_loss / iterations)
def trainStepStrech(model, x_train, centers, loss_object, optimizer, BATCH_SIZE, e):
loss_iteration = 0
......@@ -133,15 +132,15 @@ def trainStep(model, x_train, loss_object, optimizer, BATCH_SIZE, e):
return (tot_loss / iterations)
def trainRNNAE(model, nClasses, data, labelledData, labelsSmall, loss_huber, optimizer, optimizer2, BATCH_SIZE, n_epochs):
def trainRNNAE(model, nClasses, data, f_data, s_data, y_val, loss_huber, optimizer, optimizer2, BATCH_SIZE, n_epochs):
#th = 40
n_epochs_warmUp = 40
centers = None
for e in range(n_epochs_warmUp):
labelledData, labelsSmall = shuffle(labelledData, labelsSmall)
f_data, s_data, y_val, = shuffle(f_data, s_data, y_val)
data = shuffle(data)
trainLoss = trainStep(model, data, loss_huber, optimizer, BATCH_SIZE, e)
trainLoss += trainStepL(model, labelledData, labelsSmall, loss_huber, optimizer2, BATCH_SIZE, e)
trainLoss += trainStepL(model, f_data, s_data, y_val, loss_huber, optimizer2, BATCH_SIZE, e)
print("epoch %d with loss %f" % (e, trainLoss))
emb, _, _, _ = model(data)
......@@ -153,10 +152,10 @@ def trainRNNAE(model, nClasses, data, labelledData, labelsSmall, loss_huber, opt
centers = np.array(centers)
for e in range(n_epochs - n_epochs_warmUp):
labelledData, labelsSmall = shuffle(labelledData, labelsSmall)
#labelledData, labelsSmall = shuffle(labelledData, labelsSmall)
data, centers = shuffle(data, centers)
trainLoss = trainStepStrech(model, data, centers, loss_huber, optimizer, BATCH_SIZE, e)
trainLoss += trainStepL(model, labelledData, labelsSmall, loss_huber, optimizer2, BATCH_SIZE, e)
trainLoss += trainStepL(model, f_data, s_data, y_val, loss_huber, optimizer2, BATCH_SIZE, e)
print("epoch %d with loss %f" % (e, trainLoss))
return model
......@@ -185,45 +184,50 @@ def getExtractLabelSet(data, labels, nSamples):
labelledData = np.concatenate(labelledData, axis=0)
return labelledData, np.array(labelsSmall)
dataDir = sys.argv[1]
nSamples = sys.argv[2]
runId = sys.argv[3]
#Dordogne 23
data = np.load(dataDir+"/data.npy")
labels = np.load(dataDir+"/class.npy")
def main(argv):
dataDir = argv[1]
nSamples = argv[2]
runId = argv[3]
data = np.load(dataDir+"/data.npy")
labels = np.load(dataDir+"/class.npy")
idxLabelledData = np.load(dataDir+"/"+nSamples+"_"+runId+".npy")
idxLabelledData = np.load(dataDir+"/"+nSamples+"_"+runId+".npy")
labelledData = data[idxLabelledData]
labelsSmall = labels[idxLabelledData]
labelledData = data[idxLabelledData]
labelsSmall = labels[idxLabelledData]
f_data, s_data, y_val = buildPair(labelledData, labelsSmall)
print("labelledData.shape ",labelledData.shape)
print("labelsSmall.shape ",labelsSmall.shape)
origData = np.array(data)
print("labelledData.shape ",labelledData.shape)
print("labelsSmall.shape ",labelsSmall.shape)
origData = np.array(data)
nClasses = len(np.unique(labels))
nClasses = len(np.unique(labels))
RNNAE_model = RNNAE(64, data.shape[-1], nClasses, dropout_rate=0.2)
""" defining loss function and the optimizer to use in the training phase """
loss_huber = tf.keras.losses.Huber()
loss_object2 = tf.keras.losses.Huber(reduction=tf.keras.losses.Reduction.NONE)#MeanAbsoluteError()#
optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005)
optimizer2 = tf.keras.optimizers.Adam(learning_rate=0.0005)
RNNAE_model = RNNAE(64, data.shape[-1], nClasses, dropout_rate=0.2)
""" defining loss function and the optimizer to use in the training phase """
loss_huber = tf.keras.losses.Huber()
loss_object2 = tf.keras.losses.Huber(reduction=tf.keras.losses.Reduction.NONE)#MeanAbsoluteError()#
optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005)
optimizer2 = tf.keras.optimizers.Adam(learning_rate=0.0005)
BATCH_SIZE = 32
n_epochs = 100
BATCH_SIZE = 32
n_epochs = 100
RNNAE_model = trainRNNAE(RNNAE_model, nClasses, data, f_data, s_data, y_val, loss_huber, optimizer, optimizer2, BATCH_SIZE, n_epochs)
emb, _, _, _ = RNNAE_model(origData)
RNNAE_model = trainRNNAE(RNNAE_model, nClasses, data, labelledData, labelsSmall, loss_huber, optimizer, optimizer2, BATCH_SIZE, n_epochs)
emb, _, _, _ = RNNAE_model(origData)
emb = emb.numpy()
km = KMeans(n_clusters=nClasses)
km.fit(emb)
nmi = normalized_mutual_info_score(labels, km.labels_)
print("nmi %f" % nmi)
emb = emb.numpy()
km = KMeans(n_clusters=nClasses)
km.fit(emb)
nmi = normalized_mutual_info_score(labels, km.labels_)
print("nmi %f" % nmi)
if __name__ == "__main__":
main(sys.argv)
#plot2DFeatures(emb, labels)
import tensorflow as tf
class AttentionLayer(tf.keras.layers.Layer):
def __init__(self, ch_output):
super(AttentionLayer, self).__init__()
self.ch_output = ch_output
self.activation = tf.math.tanh #tf.nn.leaky_relu
self.output_activation = tf.keras.activations.softmax
def build(self, input_shape):
'''
print(input_shape)
if len(input_shape) > 1:
input_dim = input_shape[1]
else:
input_dim = input_shape
print(input_dim)
exit()
'''
input_dim = input_shape[-1]
self.A = self.add_weight(name="a_weight_matrix", shape=(self.ch_output, 1))
self.W = self.add_weight(name="W_target_nodes_weights", shape=[self.ch_output, self.ch_output])
self.tgt_node_b = self.add_weight(name='bias_target', shape=(self.ch_output,), initializer='zeros')
self.neigh_b = self.add_weight(name='bias_neigh', shape=(self.ch_output,), initializer='zeros')
def call(self, inputs, **kwargs):
#hi = inputs[0]
# target_nodes shape: batch_size x features_size F
# hj shape: batch_size x max(|N(x)|) x features_size F
#mask = tf.dtypes.cast(kwargs.get('mask'), tf.float32)
# mask shape: batch_size x max(|N(x)|)
#whi = tf.nn.bias_add(tf.tensordot(hi, self.W, axes=1), self.tgt_node_b)
# whi shape: batch_size x features_output F'
#print(inputs.get_shape())
#print(self.W.get_shape())
whj = tf.nn.bias_add(tf.tensordot(inputs, self.W, axes=1), self.neigh_b)
#print("whj ",whj.get_shape())
# whj shape: batch_size x max(|N(x)|) x features_output F'
multiply_dim = len(whj[0])
#whi = tf.tile(tf.expand_dims(whi, 1), multiples=(1, multiply_dim, 1))
# whi shape for concat: batch_size x features_output F'
#concat = whj
#concat = tf.concat([whi, whj], axis=2)
# concat shape: batch_size x max(|N(x)|) x 2F'
scores = self.activation(tf.tensordot(whj, self.A, axes=1))
scores = tf.squeeze(scores, axis=-1)
# scores shape: batch_size x max(|N(x)|)
#masked_scores = scores * mask
alphas = self.output_activation(scores)
hj = inputs * tf.expand_dims(alphas, -1)
# hj shape: batch_size x max(|N(x)|) x features_output F'
output = tf.reduce_sum(hj, axis=1)
# output shape: (batch_size x features_output F')
return output, alphas
class RNNAE(tf.keras.Model):
def __init__(self, filters, outputDim, n_cluster, dropout_rate = 0.0, hidden_activation='relu', output_activation='softmax',
name='convNetwork2',
**kwargs):
# chiamata al costruttore della classe padre, Model
super(RNNAE, self).__init__(name=name, **kwargs)
self.attention = AttentionLayer(filters)
self.attentionR = AttentionLayer(filters)
self.gate = tf.keras.layers.Dense(filters, activation='sigmoid')
self.gateR = tf.keras.layers.Dense(filters, activation='sigmoid')
self.encoder = tf.keras.layers.GRU(filters, return_sequences=True)
self.encoderR = tf.keras.layers.GRU(filters, go_backwards=True, return_sequences=True)
self.classif = tf.keras.layers.Dense(n_cluster, activation='softmax')
self.decoder = tf.keras.layers.GRU(filters, return_sequences=True)
self.decoder2 = tf.keras.layers.TimeDistributed(tf.keras.layers.Dense(units=outputDim, activation=None))
self.decoderR = tf.keras.layers.GRU(filters, return_sequences=True)
self.decoder2R = tf.keras.layers.TimeDistributed(tf.keras.layers.Dense(units=outputDim, activation=None))
#self.TDclassif = tf.keras.layers.TimeDistributed(tf.keras.layers.Dense(units=n_cluster, activation='softmax'))
def siameseDistance(self, inputs, training=False):
first_elements = inputs[0]
second_elements = inputs[1]
femb = self.encF(first_elements, training=training)
semb = self.encF(second_elements, training=training)
d_W = tf.reduce_sum( tf.square(femb - semb), axis=1)
return d_W
def encF(self, inputs, training=False):
seqEmb = self.encoder(inputs)
seqEmbR = self.encoderR(inputs)
emb = tf.unstack(seqEmb,axis=1)[-1]
embR = tf.unstack(seqEmbR,axis=1)[-1]
#emb = self.gate(emb) * emb
#embR = self.gate(embR) * embR
return emb+embR
#return tf.concat([emb,embR],axis=1)#emb+embR
def decF(self, seq_emb, emb, training=False):
dec = self.decoder(seq_emb)
decR = self.decoderR(seq_emb)
dec = self.decoder2(dec)
decR = self.decoder2R(decR)
pred = self.classif(emb)
#print(decR.get_shape())
decR = tf.reverse(decR, axis=[1])
#exit()
return dec, decR, pred
def call(self, inputs, training=False):
t = inputs.get_shape()
emb = self.encF(inputs, training)
seq_emb = tf.keras.layers.RepeatVector(t[1])(emb)
dec, decR, pred = self.decF(seq_emb, emb, training)
return emb, dec, decR, pred
#(dec+decR)/2, tf.concat((emb,embR),axis=1), tf.concat((emb,embR),axis=1), tf.concat((emb,embR),axis=1)
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment