From 3ce21ccc79c9289cb8d0c68cbaa512eaa36d4601 Mon Sep 17 00:00:00 2001
From: Antoine Barbez <antoine.brbz@gmail.com>
Date: Mon, 22 Apr 2019 20:07:36 -0400
Subject: [PATCH] implemented new training, tuning and predict scripts for smad
 and asci

---
 .DS_Store                                     | Bin 6148 -> 6148 bytes
 detection_tools/feature_envy/hist.py          |  16 ++-
 detection_tools/feature_envy/incode.py        |  16 +++
 detection_tools/feature_envy/jdeodorant.py    |  15 +++
 detection_tools/god_class/decor.py            |  18 +++-
 detection_tools/god_class/hist.py             |  13 +++
 detection_tools/god_class/jdeodorant.py       |  17 ++-
 experiments/.DS_Store                         | Bin 6148 -> 6148 bytes
 experiments/training/.DS_Store                | Bin 0 -> 6148 bytes
 experiments/training/context.py               |   5 +-
 experiments/training/train_asci.py            | 101 ++++++++++++++++++
 experiments/training/train_smad.py            |  25 +----
 experiments/tuning/.DS_Store                  | Bin 0 -> 6148 bytes
 experiments/tuning/context.py                 |   5 +-
 experiments/tuning/results/.DS_Store          | Bin 0 -> 6148 bytes
 experiments/tuning/results/asci/.DS_Store     | Bin 0 -> 6148 bytes
 .../tuning/results/asci/god_class/.DS_Store   | Bin 0 -> 6148 bytes
 experiments/tuning/results/smad/.DS_Store     | Bin 0 -> 6148 bytes
 .../tuning/results/smad/god_class/.DS_Store   | Bin 0 -> 6148 bytes
 .../tuning/results/smad_god_class_jedit.csv   | 101 ------------------
 experiments/tuning/tune_asci.py               |  93 ++++++++++++++++
 experiments/tuning/tune_smad.py               |  19 +++-
 neural_networks/.DS_Store                     | Bin 6148 -> 6148 bytes
 neural_networks/asci/.DS_Store                | Bin 0 -> 6148 bytes
 .../asci}/__init__.py                         |   0
 neural_networks/asci/context.py               |  15 +++
 neural_networks/asci/predict.py               |  29 +++++
 neural_networks/asci/trained_models/.DS_Store | Bin 0 -> 6148 bytes
 neural_networks/loss.py                       |  23 ----
 neural_networks/smad/.DS_Store                | Bin 6148 -> 6148 bytes
 neural_networks/smad/context.py               |   3 +-
 neural_networks/smad/model.py                 |  23 +++-
 neural_networks/smad/predict.py               |  34 ++++++
 .../smad/trained_models/god_class/.DS_Store   | Bin 6148 -> 6148 bytes
 utils/dataUtils.py                            |  10 +-
 utils/nnUtils.py                              |  64 ++++++-----
 36 files changed, 460 insertions(+), 185 deletions(-)
 create mode 100644 experiments/training/.DS_Store
 create mode 100644 experiments/training/train_asci.py
 create mode 100644 experiments/tuning/.DS_Store
 create mode 100644 experiments/tuning/results/.DS_Store
 create mode 100644 experiments/tuning/results/asci/.DS_Store
 create mode 100644 experiments/tuning/results/asci/god_class/.DS_Store
 create mode 100644 experiments/tuning/results/smad/.DS_Store
 create mode 100644 experiments/tuning/results/smad/god_class/.DS_Store
 delete mode 100644 experiments/tuning/results/smad_god_class_jedit.csv
 create mode 100644 experiments/tuning/tune_asci.py
 create mode 100644 neural_networks/asci/.DS_Store
 rename {experiments/training => neural_networks/asci}/__init__.py (100%)
 create mode 100644 neural_networks/asci/context.py
 create mode 100644 neural_networks/asci/predict.py
 create mode 100644 neural_networks/asci/trained_models/.DS_Store
 delete mode 100644 neural_networks/loss.py
 create mode 100644 neural_networks/smad/predict.py

diff --git a/.DS_Store b/.DS_Store
index 3cee62a72bceba8a935b785db58cf79e22beb149..4ff05ff19d77c005b9d2a78706d7e5275b286cc6 100644
GIT binary patch
delta 20
bcmZoMXffC@mywZi@;pX+M#jze7}dl8M6Ct-

delta 20
bcmZoMXffC@mywZS@;pX+MuyGz7}dl8M4JWp

diff --git a/detection_tools/feature_envy/hist.py b/detection_tools/feature_envy/hist.py
index ec5b7f4..d4990a1 100644
--- a/detection_tools/feature_envy/hist.py
+++ b/detection_tools/feature_envy/hist.py
@@ -86,4 +86,18 @@ def getSmells(systemName, alpha=2.6):
 				smells.append(m + ';' + c)
 
 		
-	return smells
\ No newline at end of file
+	return smells
+
+
+def predict(systemName):
+	entities = dataUtils.getEntities('feature_envy', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
\ No newline at end of file
diff --git a/detection_tools/feature_envy/incode.py b/detection_tools/feature_envy/incode.py
index 76e0580..44b8e3f 100644
--- a/detection_tools/feature_envy/incode.py
+++ b/detection_tools/feature_envy/incode.py
@@ -1,6 +1,8 @@
 from __future__ import division
 from context    import ROOT_DIR, dataUtils, entityUtils
 
+import numpy as np
+
 import csv
 import os
 
@@ -84,4 +86,18 @@ def getEnviedClasses(className, classAttributeMap, atfd, laa, fdp):
 	return enviedClass
 
 
+def predict(systemName):
+	entities = dataUtils.getEntities('feature_envy', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
+
+
 	
\ No newline at end of file
diff --git a/detection_tools/feature_envy/jdeodorant.py b/detection_tools/feature_envy/jdeodorant.py
index e521404..e665ca5 100644
--- a/detection_tools/feature_envy/jdeodorant.py
+++ b/detection_tools/feature_envy/jdeodorant.py
@@ -1,6 +1,8 @@
 from __future__ import division
 from context    import ROOT_DIR, dataUtils, entityUtils
 
+import numpy as np
+
 import os
 
 def getSmells(systemName):
@@ -23,3 +25,16 @@ def getSmells(systemName):
 
 	return list(set(smells))
 
+def predict(systemName):
+	entities = dataUtils.getEntities('feature_envy', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
+
diff --git a/detection_tools/god_class/decor.py b/detection_tools/god_class/decor.py
index 0a0888e..df85b21 100644
--- a/detection_tools/god_class/decor.py
+++ b/detection_tools/god_class/decor.py
@@ -1,5 +1,7 @@
 from __future__ import division
-from context    import ROOT_DIR
+from context    import ROOT_DIR, dataUtils
+
+import numpy as np
 
 import csv
 import os
@@ -31,3 +33,17 @@ def getSmells(systemName):
 					smells.append(row['ClassName'])
 
 	return smells
+
+
+def predict(systemName):
+	entities = dataUtils.getEntities('god_class', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
diff --git a/detection_tools/god_class/hist.py b/detection_tools/god_class/hist.py
index e9fa2ad..6a10e31 100644
--- a/detection_tools/god_class/hist.py
+++ b/detection_tools/god_class/hist.py
@@ -42,3 +42,16 @@ def getSmells(systemName, alpha=8.0):
 
 	return smells
 
+def predict(systemName):
+	entities = dataUtils.getEntities('god_class', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
+
diff --git a/detection_tools/god_class/jdeodorant.py b/detection_tools/god_class/jdeodorant.py
index cf12334..5304e01 100644
--- a/detection_tools/god_class/jdeodorant.py
+++ b/detection_tools/god_class/jdeodorant.py
@@ -1,4 +1,6 @@
-from context import ROOT_DIR
+from context import ROOT_DIR, dataUtils
+
+import numpy as np
 
 import os
 
@@ -8,3 +10,16 @@ def getSmells(systemName):
 	
 	with open(JDBlobFile, 'r') as file:
 		return list(set([line.split()[0] for line in file]))
+
+def predict(systemName):
+	entities = dataUtils.getEntities('god_class', systemName)
+	smells = getSmells(systemName)
+
+	prediction = []
+	for entity in entities:
+		if entity in smells:
+			prediction.append([1.])
+		else:
+			prediction.append([0.])
+
+	return np.array(prediction)
diff --git a/experiments/.DS_Store b/experiments/.DS_Store
index 068d136b80edf43db8ff57dc80dbd1c3bf2be3f6..491ccf6ba22ae3e1e3ad78b647566a665690fafd 100644
GIT binary patch
delta 67
zcmZoMXfc@J&nUDpU^g?P&}2gvnavt3xlEiX#mPBI`T02vlN;G~i?T74FqAUnF=PU9
PI!tO};mpnK9Dn%%q~{d+

delta 35
rcmZoMXfc@J&nU1lU^g?Pz+^)fnavt3xlEHcu`Qoia(Xj6$6tN`$eau7

diff --git a/experiments/training/.DS_Store b/experiments/training/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
GIT binary patch
literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

literal 0
HcmV?d00001

diff --git a/experiments/training/context.py b/experiments/training/context.py
index 9bb619b..c71ac31 100644
--- a/experiments/training/context.py
+++ b/experiments/training/context.py
@@ -5,6 +5,7 @@
 sys.path.insert(0, ROOT_DIR)
 
 import utils.dataUtils as dataUtils
-import utils.nnUtils as nnUtils
+import utils.nnUtils   as nnUtils
 
-import neural_networks.smad.model as md
\ No newline at end of file
+import neural_networks.asci.predict as asci
+import neural_networks.smad.model   as md
\ No newline at end of file
diff --git a/experiments/training/train_asci.py b/experiments/training/train_asci.py
new file mode 100644
index 0000000..f74c05c
--- /dev/null
+++ b/experiments/training/train_asci.py
@@ -0,0 +1,101 @@
+from context import nnUtils, asci
+from sklearn import tree
+
+import numpy as np
+
+import argparse
+import pickle
+
+training_systems = {
+	'android-frameworks-opt-telephony',
+	'android-platform-support',
+	'apache-ant',
+	'lucene',
+	'apache-tomcat',
+	'argouml',
+	'jedit',
+	'xerces-2_7_0'
+}
+
+def parse_args():
+	parser = argparse.ArgumentParser()
+	parser.add_argument("antipattern", help="Either 'god_class' or 'feature_envy'.")
+	parser.add_argument("test_system", help="The name of the system to be used for testing.\n Hence, the training will be performed using all the systems except this one.")
+	parser.add_argument("-n_tree", type=int, default=10, help="The number of distinct trees to be trained and saved.")
+	parser.add_argument("-min_samples_split", type=int, default=5)
+	parser.add_argument("-max_features", default='log2')
+	parser.add_argument("-max_depth", type=int, default=None)
+	parser.add_argument("-min_samples_leaf", type=int, default=2)
+	return parser.parse_args()
+
+# Build the dataset for asci, i.e., the labels are the indexes of the best tool for each input instance.
+# The order of the tools is given by the function asci.getToolsPredictions(...):
+# idx = 0: DECOR, InCode
+# idx = 1: HIST
+# idx = 2: JDeodorant
+def build_asci_dataset(antipattern, systems):
+	# Get real instances and labels
+	instances, labels = nnUtils.build_dataset(antipattern, systems)
+	
+	# Compute the performances of each tool in order to sort them accordingly
+	nb_tools = 3
+	toolsOverallPredictions = [np.empty(shape=[0, 1]) for _ in range(nb_tools)]
+	for system in systems:
+		toolsPredictions = asci.getToolsPredictions(antipattern, system)
+		for i in range(nb_tools):
+			toolsOverallPredictions[i] = np.concatenate((toolsOverallPredictions[i], toolsPredictions[i]), axis=0)
+
+	toolsPerformances = [nnUtils.f_measure(pred, labels) for pred in toolsOverallPredictions]
+
+	# Indexes of the tools, sorted according to their performances on the training set
+	toolsSortedIndexes = np.argsort(np.array(toolsPerformances))
+
+	# Assign to each instance, the index of the tool that best predicted its label.
+	# In case of conflict, assign the index of the tool that performed the best on overall.
+	
+	# Initialize with the index of the best tool as default index
+	toolsIndexes = [toolsSortedIndexes[-1] for _ in instances]
+	for i, label in enumerate(labels):
+		for toolIndex in toolsSortedIndexes:
+			if toolsOverallPredictions[toolIndex][i] == label:
+				toolsIndexes[i] = toolIndex
+
+	return instances, np.array(toolsIndexes)
+
+if __name__ == "__main__":
+	args = parse_args()
+
+	# Remove the test system from the training set and build dataset
+	training_systems.remove(args.test_system)
+	x_train, y_train = build_asci_dataset(args.antipattern, training_systems)
+
+	# Test dataset, note that here y_test contains the real labels while y_train contains tools' indexes
+	x_test, y_test = nnUtils.build_dataset(args.antipattern, [args.test_system])
+	toolsPredictions = asci.getToolsPredictions(args.antipattern, args.test_system)
+	
+	# Train and compute ensemble prediction on test set
+	predictions = np.zeros((args.n_tree, x_test.shape[0], 1))
+	for i in range(args.n_tree):
+		clf = tree.DecisionTreeClassifier(
+			min_samples_split=args.min_samples_split,
+			max_features=args.max_features,
+			max_depth=args.max_depth,
+			min_samples_leaf=args.min_samples_leaf)
+		clf = clf.fit(x_train, y_train)
+
+		# Save the tree
+		with open(nnUtils.get_save_path('asci', args.antipattern, args.test_system, i), 'wb') as save_file:
+			pickle.dump(clf, save_file)
+
+		# Compute the prediction of the current tree
+		predictedToolIndexes = clf.predict(x_test)
+		for j, toolIndex in enumerate(predictedToolIndexes): 
+			predictions[i, j, 0] = toolsPredictions[toolIndex][j]
+
+	ensemble_prediction = np.mean(predictions, axis=0)
+
+	# Print Ensemble performances
+	print("\nPerformances on " + args.test_system + ": ")
+	print('Precision: ' + str(nnUtils.precision(ensemble_prediction, y_test)))
+	print('Recall   : ' + str(nnUtils.recall(ensemble_prediction, y_test)))
+	print('F-Mesure : ' + str(nnUtils.f_measure(ensemble_prediction, y_test)))
\ No newline at end of file
diff --git a/experiments/training/train_smad.py b/experiments/training/train_smad.py
index 3f2d8f5..aa01b91 100644
--- a/experiments/training/train_smad.py
+++ b/experiments/training/train_smad.py
@@ -33,23 +33,6 @@ def parse_args():
 	parser.add_argument("-lr_decay", type=float, default=0.5, help="The factor by which the learning rate is multiplied every 'decay_step' steps")
 	return parser.parse_args()
 
-# Get the path of a trained model
-def get_save_path(antipattern, test_system, net_number):
-	directory = os.path.join(ROOT_DIR, 'neural_networks', 'smad', 'trained_models', antipattern, test_system)
-	if not os.path.exists(directory):
-			os.makedirs(directory)
-	return os.path.join(directory, 'network' + str(net_number))
-
-def build_dataset(antipattern, systems):
-	input_size = {'god_class':8, 'feature_envy':9}
-	X = np.empty(shape=[0, input_size[antipattern]])
-	Y = np.empty(shape=[0, 1])
-	for systemName in systems:
-		X = np.concatenate((X, nnUtils.getInstances(systemName, antipattern)), axis=0)
-		Y = np.concatenate((Y, nnUtils.getLabels(systemName, antipattern)), axis=0)
-
-	return X, Y
-
 # Train a single network
 def train(session, model, x_train, y_train, x_test, y_test, num_step, start_lr, beta, decay_step, lr_decay):
 	learning_rate = start_lr
@@ -79,8 +62,8 @@ def train(session, model, x_train, y_train, x_test, y_test, num_step, start_lr,
 
 	# Remove the test system from the training set and build dataset
 	training_systems.remove(args.test_system)
-	x_train, y_train = build_dataset(args.antipattern, training_systems)
-	x_test, y_test = build_dataset(args.antipattern, [args.test_system])
+	x_train, y_train = nnUtils.build_dataset(args.antipattern, training_systems)
+	x_test, y_test = nnUtils.build_dataset(args.antipattern, [args.test_system])
 
 	# Create model
 	model = md.SMAD(
@@ -118,13 +101,13 @@ def train(session, model, x_train, y_train, x_test, y_test, num_step, start_lr,
 			all_losses_test.append(losses_test)
 
 			# Save the model
-			saver.save(sess=session, save_path=get_save_path(args.antipattern, args.test_system, i))
+			saver.save(sess=session, save_path=nnUtils.get_save_path('smad', args.antipattern, args.test_system, i))
 
 
 	# Compute the ensemble prediction on the test system
 	ensemble_prediction = nnUtils.ensemble_prediction(
 		model=model, 
-		save_paths=[get_save_path(args.antipattern, args.test_system, i) for i in range(args.n_net)], 
+		save_paths=[nnUtils.get_save_path('smad', args.antipattern, args.test_system, i) for i in range(args.n_net)], 
 		input_x=x_test)
 
 	# Print Ensemble performances
diff --git a/experiments/tuning/.DS_Store b/experiments/tuning/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..7747cafb26b09eac747a6d9c20fa19fc577558c3
GIT binary patch
literal 6148
zcmeHKyJ`bL3>?LV7}B^*xxbJ<Sd9Gz{(;~)-GLz&_gCe+@@XDD2r=hWAx#*8G`l*@
zEjz{O1i&`u;}ft3u%bKS!^7PCx%<rSDq}=C-!b4F<8gc$4yRf5?Symh@rGB7IDhA#
zhT8;XrGONW0#ZN<NP%A|;Juf&dPr210#ZN<d@11Hhemhog;QdDIv8REATF5><2q&u
zV)F#C7fy-H&@8FMq*{#_mUQM@)%C(DG3l@xKCDi*noulG=lfff!+N5k6p#Yf3M_KF
z_Wr-4|1kewleCipQs7@HV9V`(yWy3px6Ur-y|&Sx>0a|mcjG!J4AG8>(T=(CcKjGc
bS=W5c=e=-B3_9~cC+cUwb&*MdzgFM^$#@mR

literal 0
HcmV?d00001

diff --git a/experiments/tuning/context.py b/experiments/tuning/context.py
index e47e0de..f4b7cb1 100644
--- a/experiments/tuning/context.py
+++ b/experiments/tuning/context.py
@@ -5,5 +5,6 @@
 sys.path.insert(0, ROOT_DIR)
 
 import utils.nnUtils as nnUtils
-import experiments.training.train_smad as train_smad
-import neural_networks.smad.model as md
\ No newline at end of file
+
+import neural_networks.asci.predict as asci
+import neural_networks.smad.model   as md
\ No newline at end of file
diff --git a/experiments/tuning/results/.DS_Store b/experiments/tuning/results/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..e951c0ca5c9f8f92cf4832ba73207ca16af30777
GIT binary patch
literal 6148
zcmeHK!AitH49(OYs)Fp%<NU&U*@Kt5)Gyc{(6*pL%PbV{^K1TsU*yXql$N$0MV16I
zZ<<V|nK#fhMC6X2?Ve~yL<N*FyT-60>}Op_rj{F^<2~A;>FN-=#Y!{$R|fd*a(bnK
z8v2;t-)QXK_NONF=gA31UmvQf?m`V;@%?c3m>s^JrW^L5{ndYdU)g)09tpMcWYoBt
zjQTc{8T}i{sDCAy$(e0x3>X8(zy&dYn$1$&3fgE47z4(@$N+yIJe09ijDqRYfg!a3
zz#Qfzm~$_|F<!A$jDqk$oP+`;)M<<1Bpi0H>q^BaDB<L^`EdGXryYt*Z^!;VEhkqB
z+Gq?I19Jwh<Z;LK|9QLrp9k5KF<=Z_6ay}=PSp`d(%QN>9M@V8eSxy@x+pk?V3JBP
f)^aJnhbDpD^8{EbMnPC0_9KvJu)!GkQwDwjt%664

literal 0
HcmV?d00001

diff --git a/experiments/tuning/results/asci/.DS_Store b/experiments/tuning/results/asci/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..f95a71e9c10300830751f4b1b5e305647e7aa374
GIT binary patch
literal 6148
zcmeHKu};G<5Iu(usbJ{H=wGN1VqpkX7+L5C07*(25?m3A#1`=%d<=iaJNr~p#jV6r
zA#^95pL4!*e9w`cBO)_fS5u-15v5SZWQ-;vJkC0hL@XR<{2Xg~p#|MRp9kJ*_=^ni
z-ks1RcI<&(slR`3^j<Hg^U^h|-okhKHZISL+7<9kZ!gcw<l^gU-`tI>e&xS<8mwhZ
zOLA1<dn>8N`dezNwyX>1YJ83q8IB|r@#?4Y@p*P5sYE@0lGyJVS$>aI?J5JxfHH7c
z2KbPKq{jiZRR)v+WnjYqpAQzwm<e_P{n3HOmjJ*K%wEvvT7qM&U?$iF#0bQMP+$l(
zQev184!ae<Ot1?W!pTVSVdTw5Diq`2j`^*3CzA!#RvAzRwi!4Ij}yNCuXoq~+d=xI
z3@8KtiUBjq=lKjN$=y0gj_+Cvy@#@}Ul(u_f{wq6;mcR?Dbx$>mOH>qunPzaM1KT4
L4caIJ2W8+JzO`C5

literal 0
HcmV?d00001

diff --git a/experiments/tuning/results/asci/god_class/.DS_Store b/experiments/tuning/results/asci/god_class/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
GIT binary patch
literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

literal 0
HcmV?d00001

diff --git a/experiments/tuning/results/smad/.DS_Store b/experiments/tuning/results/smad/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..0beb7770cecd5656bad32caafaccdc304fe0b201
GIT binary patch
literal 6148
zcmeHK!A`?440Xy5o#3z|$Na*C5El+*Dn~Bt1Aw+;99l9_hQzJnKlm8_jOWA}otjPJ
z0tnfX^U}ml?U$*ZiO9^>)s$#LL@AUp8DoeD@3Rghkrnnc{){y}(SmNEj{|F6_=^ni
z-5t?AZtRYpsegYj^ja^c^U^h|Uf?@z8<*!r?F!hY*XO5Ya`tht@9f4^-?Cpl3}PA6
zk{ng|y_HlW{+8ORE$hO$nj?;EM-qxy^;3C!Ke>`rqLyDt?6-`B&oQbf1ImCh@GA_U
zX0xP+0d-UclmTU6!vKFDER-=5>;n2v2L|5)07qE%f;smR>|+Hp!7d<nASSp1gR7Ai
z!vuG%Td~UoyMV!+j5Hrc-fW~pG5+m1-+FU0SwJ0?0cBvDfrIck;rf5MyZ_&I(kEp=
z8TeNWm{C5@XGlqE>mWI<wHA5{WnsH6;Kl_LUy5PNrT7@?1?!e4z)Y|Uh!u$b5%4tV
JpbY#d1D~mrS~UOw

literal 0
HcmV?d00001

diff --git a/experiments/tuning/results/smad/god_class/.DS_Store b/experiments/tuning/results/smad/god_class/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
GIT binary patch
literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

literal 0
HcmV?d00001

diff --git a/experiments/tuning/results/smad_god_class_jedit.csv b/experiments/tuning/results/smad_god_class_jedit.csv
deleted file mode 100644
index 22f9461..0000000
--- a/experiments/tuning/results/smad_god_class_jedit.csv
+++ /dev/null
@@ -1,101 +0,0 @@
-Learning rate;Beta;Dense sizes;F-measure
-0.187625311004;0.14675747497;[37];0.5205479452054794
-0.242540118664;0.111539495108;[92, 30, 7];0.5165562913907285
-0.0576728013128;0.0279349021;[73, 22, 5];0.5151515151515151
-0.0518786345733;0.139677933123;[86, 83, 27];0.5142857142857143
-0.0673408441308;0.0673230293947;[25, 8, 6];0.5070422535211269
-0.0267080986256;0.0152451192183;[93, 26, 8];0.5033112582781457
-0.0311032954781;0.0386569620065;[100, 100];0.5
-0.213815471538;0.0304431998344;[28, 8, 8];0.4971098265895954
-0.41141073225;0.00935042747354;[42, 36];0.49664429530201337
-0.0767772225021;0.290650469376;[50, 46];0.49275362318840576
-0.523062412575;0.00359283334364;[37, 19];0.48854961832061067
-0.41922727536;0.0207480660613;[70, 26, 25];0.488095238095238
-0.226675137981;0.0677445110781;[46];0.48780487804878053
-0.233111227278;0.0109480536631;[16, 8];0.48366013071895425
-0.300110153836;0.0825943663458;[91, 47, 27];0.48322147651006714
-0.0327801077527;0.00397447772989;[88, 86, 82];0.48226950354609927
-0.0500852749125;0.0421708196263;[84, 34];0.48226950354609927
-0.157904542009;0.0489894863328;[93, 35, 20];0.481203007518797
-0.235254308971;0.129223814791;[99, 6, 5];0.4806201550387597
-0.349744734361;0.0895465088309;[61, 12];0.4696969696969697
-0.85599017676;0.0049801835805;[68, 63, 19];0.4600000000000001
-0.23820006473;0.00337728335754;[55];0.45925925925925926
-0.696660351954;0.00605014468883;[90];0.45833333333333337
-0.521710749067;0.0531599404738;[32];0.4578313253012048
-0.581053195198;0.0065973177479;[95, 92, 72];0.45614035087719296
-0.569910465955;0.012661999135;[42, 16, 10];0.4512820512820513
-0.0849450790357;0.193346121571;[38, 8, 6];0.448
-0.514930761237;0.116705112524;[39, 31];0.44670050761421315
-0.20066702827;0.016933463796;[86, 6];0.4444444444444445
-0.430029378442;0.0146752953346;[19, 13];0.4444444444444445
-0.677078288941;0.116114004774;[96];0.4419889502762431
-0.0387443705299;0.0952209864936;[64, 14, 7];0.43678160919540227
-0.159563120414;0.0107310916222;[21, 20, 7];0.4264705882352941
-0.367522228601;0.0041977616693;[17, 11, 6];0.4197530864197531
-0.36551226629;0.0210275757725;[61];0.41666666666666663
-0.0672510156293;0.265729230812;[15];0.4097560975609756
-0.632926800839;0.200424526599;[44];0.38862559241706157
-0.0771137301817;0.140917366343;[20];0.3374485596707819
-0.0675845526487;0.575567813039;[15];0.3274021352313167
-0.0315757784368;0.00873004644068;[29];0.3047619047619048
-0.0806591303696;0.0299125069307;[30];0.29365079365079366
-0.0358852263939;0.0077475104817;[30, 5];0.2336182336182336
-0.0185634461312;0.94839319324;[46, 39];0.2292993630573248
-0.00997371678202;0.00692451846682;[99, 90];0.19659735349716445
-0.0172259419392;0.773520904708;[57];0.19063545150501673
-0.0192220822374;0.0074529785417;[28];0.18791946308724833
-0.00775506126011;0.208671948166;[72, 70, 41];0.17812499999999998
-0.025782841518;0.263117989012;[48];0.15384615384615383
-0.20164635998;0.00904945612594;[4];0.1491395793499044
-0.0146668968654;0.132363178673;[54, 36];0.14825174825174825
-0.0244971929407;0.0377305752096;[24, 9, 8];0.1364221364221364
-0.043488731109;0.198525517026;[38, 6, 6];0.13553719008264464
-0.0115054498015;0.0456030013482;[84];0.1322314049586777
-0.0161597814023;0.75952092995;[25];0.12817679558011047
-0.0291452447242;0.18302832017;[7];0.12468827930174566
-0.0169354916449;0.18872179022;[37, 23];0.12311265969802555
-0.0567147888183;0.00337946451529;[32, 18];0.1174863387978142
-0.020165766387;0.198471337686;[40];0.1101511879049676
-0.0288530570004;0.0232640207533;[21];0.10477299185098952
-0.00637426286374;0.212162122731;[46, 22, 21];0.09975062344139651
-0.488728898928;0.239170015427;[34, 18];0.09780439121756489
-0.00881665610108;0.015779562476;[79, 21];0.09760425909494232
-0.00629958971871;0.0807374795471;[73, 27];0.09741550695825049
-0.0139390457484;0.0113725931467;[28, 25];0.09573542210617929
-0.00353404588975;0.0184318170263;[89, 8];0.09416581371545546
-0.0120791978773;0.183021301698;[66, 16];0.09075342465753423
-0.00620167083462;0.207947728748;[95, 34];0.08849557522123895
-0.0118407887201;0.00935544694392;[65, 45];0.0855614973262032
-0.0055747321968;0.187588683955;[30, 25];0.08548707753479126
-0.0330444112935;0.0450198146887;[4, 4];0.08482142857142858
-0.00887710338536;0.0139892514367;[29, 27, 25];0.08235294117647057
-0.00813959647552;0.00326927246043;[52, 35, 14];0.07971014492753625
-0.0564239852881;0.0125519862372;[7, 4];0.07518796992481203
-0.00927245329718;0.224079957675;[44];0.07396664249456128
-0.038134999858;0.00428911519924;[10];0.0694980694980695
-0.00553237978431;0.0223508358307;[96, 9, 7];0.06744666207845837
-0.0257345627096;0.0320198266225;[16, 5];0.06525285481239804
-0.0061013365831;0.00438961751565;[24, 13, 9];0.061538461538461535
-0.450022324106;0.449015783908;[31];0.06070826306913996
-0.010338295358;0.00464760878807;[83, 5];0.058452722063037255
-0.00790175250821;0.00661985365521;[29, 12, 8];0.05751633986928104
-0.0183609220109;0.0218678540961;[13];0.05656819610307982
-0.170432453544;0.22164653729;[15, 13, 6];0.05593607305936072
-0.00440426281999;0.0187248538163;[40, 30, 21];0.05402542372881356
-0.014217128222;0.017224569319;[9];0.05366492146596858
-0.00455953923729;0.213867004434;[42, 37, 17];0.053128689492325853
-0.00932510571364;0.100131659847;[13];0.04398689751988769
-0.00756230203124;0.0443855465015;[8];0.040201005025125636
-0.00511983439921;0.00328902664239;[90, 39];0.04008908685968819
-0.489651305922;0.280614674322;[9, 5, 4];0.03248924988055423
-0.060735594726;0.978996697146;[86, 38, 13];0.03248924988055423
-0.0938976874343;0.659811776069;[85, 15];0.03248924988055423
-0.105161372625;0.735831832433;[15, 12];0.03248924988055423
-0.161824541463;0.930964885054;[61];0.03248924988055423
-0.485893474095;0.775913010563;[55];0.03248924988055423
-0.508516969085;0.372844508898;[31, 22, 11];0.03248924988055423
-0.48969476847;0.504910514286;[17];0.03248924988055423
-0.00611084309339;0.0214893186361;[63];0.03002421307506053
-0.00390184507626;0.0292952263152;[22, 18];0.026812313803376366
-0.00339056311938;0.00371395072775;[11, 10];0.011393847322445878
diff --git a/experiments/tuning/tune_asci.py b/experiments/tuning/tune_asci.py
new file mode 100644
index 0000000..3ecde9e
--- /dev/null
+++ b/experiments/tuning/tune_asci.py
@@ -0,0 +1,93 @@
+from context import ROOT_DIR, nnUtils, asci
+from sklearn.model_selection import RandomizedSearchCV
+from sklearn import tree
+
+import numpy as np
+
+import argparse
+import os
+
+training_systems = {
+	'android-frameworks-opt-telephony',
+	'android-platform-support',
+	'apache-ant',
+	'lucene',
+	'apache-tomcat',
+	'argouml',
+	'jedit',
+	'xerces-2_7_0'
+}
+
+def parse_args():
+	parser = argparse.ArgumentParser()
+	parser.add_argument("antipattern", help="Either 'god_class' or 'feature_envy'.")
+	parser.add_argument("test_system", help="The name of the system to be used for testing.\n Hence, the training will be performed using all the systems except this one.")
+	parser.add_argument("-n_fold", type=int, default=5, help="Number of folds (k) for a k-fold-cross-validation")
+	parser.add_argument("-n_test", type=int, default=100, help="Number of random hyper-parameters sets to be tested")
+	return parser.parse_args()
+
+# Build the dataset for asci, i.e., the labels are the indexes of the best tool for each input instance.
+# The order of the tools is given by the function asci.getToolsPredictions(...):
+# idx = 0: DECOR, InCode
+# idx = 1: HIST
+# idx = 2: JDeodorant
+def build_asci_dataset(antipattern, systems):
+	# Get real instances and labels
+	instances, labels = nnUtils.build_dataset(antipattern, systems)
+	
+	# Compute the performances of each tool in order to sort them accordingly
+	nb_tools = 3
+	toolsOverallPredictions = [np.empty(shape=[0, 1]) for _ in range(nb_tools)]
+	for system in systems:
+		toolsPredictions = asci.getToolsPredictions(antipattern, system)
+		for i in range(nb_tools):
+			toolsOverallPredictions[i] = np.concatenate((toolsOverallPredictions[i], toolsPredictions[i]), axis=0)
+
+	toolsPerformances = [nnUtils.f_measure(pred, labels) for pred in toolsOverallPredictions]
+
+	# Indexes of the tools, sorted according to their performances on the training set
+	toolsSortedIndexes = np.argsort(np.array(toolsPerformances))
+
+	# Assign to each instance, the index of the tool that best predicted its label.
+	# In case of conflict, assign the index of the tool that performed the best on overall.
+	
+	# Initialize with the index of the best tool as default index
+	toolsIndexes = [toolsSortedIndexes[-1] for _ in instances]
+	for i, label in enumerate(labels):
+		for toolIndex in toolsSortedIndexes:
+			if toolsOverallPredictions[toolIndex][i] == label:
+				toolsIndexes[i] = toolIndex
+
+	return instances, np.array(toolsIndexes)
+
+if __name__ == "__main__":
+	args = parse_args()
+
+	# Remove the test system from the training set and build dataset
+	training_systems.remove(args.test_system)
+	data_x, data_y = build_asci_dataset(args.antipattern, training_systems)
+
+	random_grid = {
+		'max_features': ['sqrt', 'log2', None],
+		'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, None],
+		'min_samples_leaf': [1, 2, 4, 6],
+ 		'min_samples_split': [2, 5, 10, 15]}
+
+	cross_validation = RandomizedSearchCV(
+		estimator = tree.DecisionTreeClassifier(),
+		param_distributions = random_grid, 
+		n_iter = args.n_test, 
+		cv = args.n_fold,
+		verbose=2, 
+		n_jobs = -1)
+
+	cross_validation.fit(data_x, data_y)
+	best_params = cross_validation.best_params_
+
+	tuning_results_file = os.path.join(ROOT_DIR, 'experiments', 'tuning', 'results', 'asci', args.antipattern, args.test_system + '.csv')
+	with open(tuning_results_file, 'w') as file:
+		for key in best_params:
+			file.write(str(key) + ';')
+		file.write('\n')
+		for key in best_params:
+			file.write(str(best_params[key]) + ';')
\ No newline at end of file
diff --git a/experiments/tuning/tune_smad.py b/experiments/tuning/tune_smad.py
index beb3161..1e60564 100644
--- a/experiments/tuning/tune_smad.py
+++ b/experiments/tuning/tune_smad.py
@@ -1,4 +1,4 @@
-from context import ROOT_DIR, nnUtils, train_smad, md
+from context import ROOT_DIR, nnUtils, md
 
 import tensorflow        as tf
 import numpy             as np
@@ -9,6 +9,17 @@
 import random
 os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
 
+training_systems = {
+	'android-frameworks-opt-telephony',
+	'android-platform-support',
+	'apache-ant',
+	'lucene',
+	'apache-tomcat',
+	'argouml',
+	'jedit',
+	'xerces-2_7_0'
+}
+
 def parse_args():
 	parser = argparse.ArgumentParser()
 	parser.add_argument("antipattern", help="Either 'god_class' or 'feature_envy'")
@@ -58,15 +69,15 @@ def train(session, model, x_train, y_train, num_step, lr, beta):
 	args = parse_args()
 
 	# Remove the test system from the training set and build dataset
-	train_smad.training_systems.remove(args.test_system)
-	data_x, data_y = train_smad.build_dataset(args.antipattern, train_smad.training_systems)
+	training_systems.remove(args.test_system)
+	data_x, data_y = nnUtils.build_dataset(args.antipattern, training_systems)
 	data_x, data_y = nnUtils.shuffle(data_x, data_y)
 
 	bar = progressbar.ProgressBar(maxval=args.n_test, \
 		widgets=['Performing cross validation for ' + args.test_system + ': ' ,progressbar.Percentage()])
 	bar.start()
 
-	output_file_path = os.path.join(ROOT_DIR, 'experiments', 'tuning', 'results', 'smad_' + args.antipattern + '_' + args.test_system + '.csv')
+	output_file_path = os.path.join(ROOT_DIR, 'experiments', 'tuning', 'results', 'smad', args.antipattern, args.test_system + '.csv')
 
 	params = []
 	perfs  = []
diff --git a/neural_networks/.DS_Store b/neural_networks/.DS_Store
index f7dd3e8145f237fd1301bc4a11af793824929573..a9f207515f7edd6fc3ff8c9512f460dd9754dc93 100644
GIT binary patch
delta 63
zcmZoMXfc@JFUZZnz`)4BAi$7PoSc)CpP#e2k$E*EFG!e$A(5e&A(<g_vL2H*5I<#P
P+$_R;k7YAE$6tN`(%uhv

delta 54
zcmZoMXfc@JFUrNhz`)4BAi%&-#E{BRz>vd`$&kD;aXBL+*Jec~c1A{q&6>>jSSA*T
KZf58B%MSo8Nen;$

diff --git a/neural_networks/asci/.DS_Store b/neural_networks/asci/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..92544954fceb937c9d01db5039337085374e1042
GIT binary patch
literal 6148
zcmeHKJ5Iw;5S)b+k&vR4l<x}Mz>2~NasYm&Kr&b&(7WPX9F5tJkSvFSf(Fe>yYt?@
zoo9IpuNQ#r-uo+H3t&xm#D|Ba`MLYT&MIR>I`4SFBYNE68RMe*bi%nCyx|phc$)Eh
z-ZkLZA0LMMaU4$5m6ZZgKnh3!DIf)Yset!h+WI0<Q3^-_De$d;e;*p%u`8Ss<I}+q
zBLH#5bQsq$OAwnUh+W~7$PCSrN=&NNh+#=*zExdUI3*?>R>OzYldUEci>LGc7Ui%m
zQBev=fw=<bx!rpIzo!2%|IbO<NdYPFuN1J={;=Qim8!QcUe0@Mqu<iK=9BKmbx;_h
l9TTG+bK~v!GK#XU`I_fl;glG3=7Ubu&w%S9lLCLOz!wB}7b*Y%

literal 0
HcmV?d00001

diff --git a/experiments/training/__init__.py b/neural_networks/asci/__init__.py
similarity index 100%
rename from experiments/training/__init__.py
rename to neural_networks/asci/__init__.py
diff --git a/neural_networks/asci/context.py b/neural_networks/asci/context.py
new file mode 100644
index 0000000..e50c4d0
--- /dev/null
+++ b/neural_networks/asci/context.py
@@ -0,0 +1,15 @@
+import os
+import sys
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.insert(0, ROOT_DIR)
+
+import detection_tools.god_class.hist       as hist_gc
+import detection_tools.god_class.decor      as decor_gc
+import detection_tools.god_class.jdeodorant as jdeodorant_gc
+
+import detection_tools.feature_envy.hist       as hist_fe
+import detection_tools.feature_envy.incode     as incode_fe
+import detection_tools.feature_envy.jdeodorant as jdeodorant_fe
+
+import utils.nnUtils as nnUtils
\ No newline at end of file
diff --git a/neural_networks/asci/predict.py b/neural_networks/asci/predict.py
new file mode 100644
index 0000000..060793e
--- /dev/null
+++ b/neural_networks/asci/predict.py
@@ -0,0 +1,29 @@
+from context import nnUtils, decor_gc, incode_fe, hist_gc, hist_fe, jdeodorant_gc, jdeodorant_fe
+from sklearn import tree
+
+import numpy as np
+
+import pickle
+
+# Returns a list containing the predictions of each approach/tool.
+def getToolsPredictions(antipattern, system):
+	assert antipattern in ['god_class', 'feature_envy']
+	if antipattern == 'god_class':
+		return [decor_gc.predict(system), hist_gc.predict(system), jdeodorant_gc.predict(system)]
+	else:
+		return [incode_fe.predict(system), hist_fe.predict(system), jdeodorant_fe.predict(system)]
+
+def predict(antipattern, system):
+	toolsPredictions = getToolsPredictions(antipattern, system)
+	X = nnUtils.getInstances(antipattern, system)
+
+	# Ensemble Prediction
+	predictions = np.zeros((10, X.shape[0], 1))
+	for i in range(10):
+		with open(nnUtils.get_save_path(i), 'r') as file:
+			clf = pickle.load(file)
+			predictedToolIndexes = clf.predict(X)
+			for j, toolIndex in enumerate(predictedToolIndexes): 
+				predictions[i, j, 0] = toolsPredictions[toolIndex][j]
+  	
+	return np.mean(predictions, axis=0)
\ No newline at end of file
diff --git a/neural_networks/asci/trained_models/.DS_Store b/neural_networks/asci/trained_models/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..acc36ce79bdc6bc75c8bd39d753e1910908cad3f
GIT binary patch
literal 6148
zcmeHKyH3ME5S)b+K{P2T?-%%kQxv{{58x3?G?rXg^se|WJ}t8kAtHwci3ZI|yK}eR
z@#&`UdI8w}eYgj90Jd~Te0W%!KX+f*Rb`Aw=R1xV@q!uiFt4gFC!BkOH%u7t^qqek
zU#DrjOj1?~NC7Dz1*Cu!__YGwduiL-L`5ke1*E{20{(qybjMz}B*v$MAw~e=hUqY_
zW0oK`PY`?IlE@6rl1faf)ret9XTDWkFI*Cn4y)nA>SU`4#o~0nzePE$Cn`z-DR8d9
zb#8aw{~zc-%>U;k?WBMd_*V+p=J0sf^GelQSC{i%+vv}9ulc0AaUB$fXvf58$J}^3
ezKf!)Yrf|5UbrL%o%x^>^)ukQ$fUquD{unV*%gHV

literal 0
HcmV?d00001

diff --git a/neural_networks/loss.py b/neural_networks/loss.py
deleted file mode 100644
index 14fc51a..0000000
--- a/neural_networks/loss.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from __future__ import division
-
-import tensorflow as tf
-
-def f_measure_approx(logits, labels, gamma):
-    ''' 
-    This function implements the Differentiable approximation of the f-measure from:
-    Martin Jansche (2005):
-        [Maximum Expected F-Measure Training of Logistic Regression Models]
-
-    true_positive:  sum(sigmoid(gamma*logits)) for label = +1
-    detected: sum(sigmoid(gamma*logits))
-    gamma > 0
-    '''
-    true_positive = tf.reduce_sum(tf.multiply(labels, tf.nn.sigmoid(gamma*logits)))
-    positive = tf.reduce_sum(labels)
-    detected = tf.reduce_sum(tf.nn.sigmoid(gamma*logits))
-
-    return 2*true_positive/(positive+detected)
-
-# Custom loss function that maximizes f-measure  
-def compute(logits, labels):
-    return 1 - f_measure_approx(logits, labels, 4)
\ No newline at end of file
diff --git a/neural_networks/smad/.DS_Store b/neural_networks/smad/.DS_Store
index 24d0c2b3d71d59eae7e05a1784d63468531b8aeb..ff1341055ae20d5e2177e1e43ebad8d7a8ab6dac 100644
GIT binary patch
delta 18
ZcmZoMXffDe!pO)tnTJtfb136_F#s@|1l|Au

delta 18
ZcmZoMXffDe!pO)lnTJtfb136_F#s@;1l<4t

diff --git a/neural_networks/smad/context.py b/neural_networks/smad/context.py
index 23bad9c..2c70b53 100644
--- a/neural_networks/smad/context.py
+++ b/neural_networks/smad/context.py
@@ -4,4 +4,5 @@
 ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 sys.path.insert(0, ROOT_DIR)
 
-import neural_networks.loss as loss
\ No newline at end of file
+import neural_networks.loss as loss
+import utils.nnUtils        as nnUtils
\ No newline at end of file
diff --git a/neural_networks/smad/model.py b/neural_networks/smad/model.py
index 8a5bf48..ef73516 100644
--- a/neural_networks/smad/model.py
+++ b/neural_networks/smad/model.py
@@ -1,4 +1,4 @@
-from context import loss
+from __future__ import division
 
 import tensorflow as tf
 
@@ -42,9 +42,28 @@ def __init__(self, shape, input_size):
 
 		# Loss function
 		with tf.name_scope("loss"):
-			self.loss = loss.compute(self.logits, self.input_y)
+			self.loss = loss(self.logits, self.input_y)
 			l2_loss = tf.losses.get_regularization_loss()
 			loss_reg = self.loss + l2_loss
 
 		# Learning mechanism
 		self.learning_step = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(loss_reg)
+
+
+def loss(logits, labels):
+	''' 
+	This function implements the Differentiable approximation of the f-measure from:
+	Martin Jansche (2005):
+	    [Maximum Expected F-Measure Training of Logistic Regression Models]
+
+	true_positive:  sum(sigmoid(gamma*logits)) for label = +1
+	detected: sum(sigmoid(gamma*logits))
+	gamma > 0
+	'''
+	gamma = 4
+
+	true_positive = tf.reduce_sum(tf.multiply(labels, tf.nn.sigmoid(gamma*logits)))
+	positive = tf.reduce_sum(labels)
+	detected = tf.reduce_sum(tf.nn.sigmoid(gamma*logits))
+
+	return 1 - 2*true_positive/(positive+detected)
diff --git a/neural_networks/smad/predict.py b/neural_networks/smad/predict.py
new file mode 100644
index 0000000..0a0c703
--- /dev/null
+++ b/neural_networks/smad/predict.py
@@ -0,0 +1,34 @@
+from context import ROOT_DIR, nnUtils
+
+import model as md
+
+import ast
+import csv
+import os
+
+def get_optimal_parameters(antipattern, system):
+	tuning_file = os.path.join(ROOT_DIR, 'experiments', 'tuning', 'results', 'smad', antipattern, test_system + '.csv')
+
+	with open(tuning_file, 'r') as file:
+		reader = csv.DictReader(file, delimiter=';')
+
+		for row in reader:
+			if row['F-measure'] != 'nan':
+				return {key:ast.literal_eval(row[key]) for key in row}
+
+def predict(antipattern, system):
+	params = get_optimal_parameters(antipattern, system)
+	X = nnUtils.getInstances(antipattern, system)
+
+	# New graph
+	tf.reset_default_graph()
+
+	# Create model
+	model = md.SMAD(
+		shape=params['Dense sizes'], 
+		input_size=X.shape[-1])
+
+	return nnUtils.ensemble_prediction(
+		model=model,
+		save_paths=[nnUtils.get_save_path('smad', antipattern, system, i) for i in range(10)], 
+		input_x=X)
\ No newline at end of file
diff --git a/neural_networks/smad/trained_models/god_class/.DS_Store b/neural_networks/smad/trained_models/god_class/.DS_Store
index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..715af757fcc7fc97a1dc0807efa951ed9fb863c2 100644
GIT binary patch
delta 75
zcmZoMXfc?eJ=s8n#h8^Liy@UEg&~unB&9exCn-NahXDkbz$60$BajAS0S1Kp#>A!U
MAibNpIezj30BBYa+5i9m

delta 51
vcmZoMXfc?e&B4IH0LBvwMFg0D92j6^U=Y|?IE{T`gVbaL5thx|96$L1%DD*$

diff --git a/utils/dataUtils.py b/utils/dataUtils.py
index e925869..85637ae 100644
--- a/utils/dataUtils.py
+++ b/utils/dataUtils.py
@@ -87,7 +87,7 @@ def getMethods(systemName):
     return methods
 
 # Get the hand-validated occurences reported in the considered system for antipattern in [god_class, feature_envy].
-def getAntipatterns(systemName, antipattern):
+def getAntipatterns(antipattern, systemName):
     assert antipattern in ['god_class', 'feature_envy'], antipattern + ' not valid antipattern name. Choose "god_class" or "feature_envy instead"'
 
     labelFile = os.path.join(ROOT_DIR, 'data/antipatterns/' + antipattern + '/' + systemName + '.txt')
@@ -113,6 +113,14 @@ def getCandidateFeatureEnvy(systemName):
             if (entityUtils.getEmbeddingClass(entityUtils.normalizeMethodName(row['Method']))!=row['TargetClass']) & (entityUtils.normalizeMethodName(row['Method']) in methods) & (row['TargetClass'] in classes)]  
 
 
+def getEntities(antipattern, systemName):
+    assert antipattern in ['god_class', 'feature_envy']
+
+    if antipattern == 'god_class':
+        return getClasses(systemName)
+    else:
+        return getCandidateFeatureEnvy(systemName)
+
 ### METRICS GETTERS FOR GOD CLASS ###
 
 def getGCDecorMetrics(systemName):
diff --git a/utils/nnUtils.py b/utils/nnUtils.py
index 3463009..7bce13f 100644
--- a/utils/nnUtils.py
+++ b/utils/nnUtils.py
@@ -6,6 +6,7 @@
 import matplotlib.pyplot as plt
 
 import dataUtils
+import os
 import random
 import sys
 
@@ -33,24 +34,16 @@ def f_measure(output, labels):
 
 
 ### UTILS ###
-def shuffle(X, Y):
-	assert len(X) == len(Y), 'X and Y must have the same number of elements'
 
-	idx = range(len(X))
-	random.shuffle(idx)
+def build_dataset(antipattern, systems):
+	input_size = {'god_class':8, 'feature_envy':9}
+	X = np.empty(shape=[0, input_size[antipattern]])
+	Y = np.empty(shape=[0, 1])
+	for systemName in systems:
+		X = np.concatenate((X, getInstances(antipattern, systemName)), axis=0)
+		Y = np.concatenate((Y, getLabels(antipattern, systemName)), axis=0)
 
-	shuffled_X = np.array([X[i] for i in idx])
-	shuffled_Y = np.array([Y[i] for i in idx])
-	
-	return shuffled_X, shuffled_Y
-
-def split(X, Y, nb_split):
-	assert len(X) == len(Y), 'X and Y must have the same number of elements' 
-	
-	length = len(X)//nb_split
-	sections  = [(i+1)*length for i in range(nb_split-1)]
-
-	return np.split(X, sections), np.split(Y, sections)
+	return X, Y
 
 # Returns the Bayesian averaging between many network's predictions
 def ensemble_prediction(model, save_paths, input_x):
@@ -64,6 +57,13 @@ def ensemble_prediction(model, save_paths, input_x):
 
 	return np.mean(np.array(predictions), axis=0)
 
+# Get the path of a trained model for a given approach (smad or asci)
+def get_save_path(approach, antipattern, test_system, model_number):
+	directory = os.path.join(ROOT_DIR, 'neural_networks', approach, 'trained_models', antipattern, test_system)
+	if not os.path.exists(directory):
+			os.makedirs(directory)
+	return os.path.join(directory, 'model_' + str(model_number))
+
 def plot_learning_curves(losses_train, losses_test):
 	plt.figure()
 	plt.ylim((0.0, 1.0))
@@ -88,21 +88,35 @@ def plot_learning_curves(losses_train, losses_test):
 	plt.legend(loc='best')
 	plt.show()
 
+def shuffle(X, Y):
+	assert len(X) == len(Y), 'X and Y must have the same number of elements'
+
+	idx = range(len(X))
+	random.shuffle(idx)
+
+	shuffled_X = np.array([X[i] for i in idx])
+	shuffled_Y = np.array([Y[i] for i in idx])
+	
+	return shuffled_X, shuffled_Y
+
+def split(X, Y, nb_split):
+	assert len(X) == len(Y), 'X and Y must have the same number of elements' 
+	
+	length = len(X)//nb_split
+	sections  = [(i+1)*length for i in range(nb_split-1)]
+
+	return np.split(X, sections), np.split(Y, sections)
+
 
 ### INSTANCES AND LABELS GETTERS ###
 
 # Get labels in vector form for a given system
 # antipattern in ['god_class', 'feature_envy']
-def getLabels(systemName, antipattern):
-	assert antipattern in ['god_class', 'feature_envy']
-
-	if antipattern == 'god_class':
-		entities = dataUtils.getClasses(systemName)
-	else:
-		entities = dataUtils.getCandidateFeatureEnvy(systemName)
+def getLabels(antipattern, systemName):
+	entities = dataUtils.getEntities(antipattern, systemName)
+	true = dataUtils.getAntipatterns(antipattern, systemName)
 
 	labels = []
-	true = dataUtils.getAntipatterns(systemName, antipattern)
 	for entity in entities:
 		if entity in true:
 			labels.append([1.])
@@ -112,7 +126,7 @@ def getLabels(systemName, antipattern):
 	return np.array(labels)
 
 
-def getInstances(systemName, antipattern, normalized=True):
+def getInstances(antipattern, systemName, normalized=True):
 	assert antipattern in ['god_class', 'feature_envy']
 
 	metrics = []