def distribution(directory, version, model, batch_size, resize):
print("Calculate mean of distribution")
#• directory = "Model-7"
createFolder(directory)
createFolder(directory + "\\" + version)
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_test = dataSetPair.pair_money_test
pair_validation = dataSetPair.pair_money_val
pair_money_train_loader = DataLoader(pair_train,
batch_size=batch_size,
num_workers=0,
shuffle=True)
pair_money_test_loader = DataLoader(pair_test,
batch_size=batch_size,
num_workers=0)
pair_money_val_loader = DataLoader(pair_validation,
batch_size=batch_size,
num_workers=0)
gaussian_distribition(directory,
version,
model,
pair_money_train_loader,
pair_money_val_loader,
pair_money_test_loader,
resize,
batch_size,
exp_name='model_1')
def continue_siamese(directory,namefile,version,path, exp_name,name,model, lr, epochs, momentum, batch_size,resize, margin, logs):
siamese_reload, f, array_loss_train, array_loss_valid, array_sample_train, array_sample_valid, array_acc_train, array_acc_valid,labels_train,prediction_train,labels_val,prediction_val=train_continue(directory,version,path,exp_name,name, model,lr, epochs, momentum,batch_size,resize, margin, logs)
print("time Training\n ", f)
print("Loss on train", array_loss_train[-1])
print("Loss on valid\n", array_loss_valid[-1])
directory= "Model-1-Continue"
#controlla se è presente la directory, altrimenti la crei
createFolder(directory)
#plot
plotLoss(directory,namefile,array_loss_train, array_loss_valid, array_sample_train, array_sample_valid)
plotAccuracy(directory,namefile,array_acc_train,array_acc_valid,array_sample_train,array_sample_valid)
scoresTrain= calculateScore(labels_train,prediction_train)
scoresValid = calculateScore(labels_val,prediction_val)
print("Score on data Train...")
print("Accuarcy di train: %0.4f"% scoresTrain[0])
print("Precision di train: %0.4f"% scoresTrain[1])
print("Recall di train: %0.4f"% scoresTrain[2])
print("mF1 score di train: %0.4f"% scoresTrain[3])
print("Score on dataValid...")
print("Accuarcy di validation: %0.4f"% scoresValid[0])
print("Precision di validation: %0.4f"% scoresValid[1])
print("Recall di validation: %0.4f"% scoresValid[2])
print("mF1 score di validation: %0.4f"% scoresValid[3])
valueTime = readJson(directory+"/ModelTrained.json",version,"time","training")
epoche = readJson(directory+"/ModelTrained.json",version,"hyperparametr","indexEpoch")
if not valueTime is None:
f = float(valueTime) + float(f)
if not epoche is None:
epochs = epochs + epoche
hyperparametr = {"indexEpoch":epochs,"lr":lr, "momentum" : momentum, "numSampleTrain": len(labels_train) }
contrastiveLoss = {"lossTrain": array_loss_train[-1], "lossValid": array_loss_valid[-1] }
accuracy = {"accuracyTrain":scoresTrain[0] , "accuracyValid":scoresValid[0] }
precision = {"precisionTrain":scoresTrain[1] , "precisionValid":scoresValid[1] }
recall = {"recallTrain":scoresTrain[2] , "recallValid":scoresValid[2] }
f1score = {"f1_score_Train":scoresTrain[3] , "f1_score_Valid":scoresValid[3]}
time = {"training": str(f)}
writeJsonModel(directory,name,version, hyperparametr, batch_size, contrastiveLoss, accuracy ,f1score, precision, recall, time)
def classificazione(directory,filename, version,exp_name,name, model,lr, epochs, momentum, batch_size, resize):
print("Classificazione")
#directory "Class"
directory =directory
version=version
lr=lr
epochs=epochs
momentum=momentum
batch_size = batch_size
resize=resize
controlFileCSVBase()
dataSetClass = DatasetClassi(resize)
dataSetClass.controlNormalize()
train = dataSetClass.dataset_train_norm
validation = dataSetClass.dataset_valid_norm
test = dataSetClass.dataset_test_norm
print("Numeri campioni",len(train))
createFolder(directory)
createFolder(directory+"\\"+version)
writeJsonModelInit1(directory,name,version)
money_train_loader = DataLoader(train, batch_size=batch_size, num_workers=0, shuffle=True)
money_test_loader = DataLoader(test, batch_size=batch_size, num_workers=0)
money_val_loader = DataLoader(validation , batch_size = batch_size, num_workers=0)
print("Numero di batch", len(money_train_loader))
modello ,f, last_loss_train, last_loss_val, last_acc_train, last_acc_val = train_class(directory,version, model, money_train_loader, money_val_loader,resize, batch_size, exp_name , lr=lr, epochs = epochs)
print("Time computing", f)
print("last_loss_train",last_loss_train)
print("last_loss_val",last_loss_val)
print("last_acc_train",last_acc_train)
print("last_acc_val",last_acc_val)
hyperparametr = {"indexEpoch":epochs-1,"lr":lr, "momentum" : momentum, "batchSize":batch_size }
contrastiveLoss = {"lossTrain": last_loss_train, "lossValid":last_loss_val}
accuracy = {"accuracyTrain":last_acc_train , "accuracyValid":last_acc_val }
time = {"training": f}
writeJsonModelClass(directory,name,version, hyperparametr,resize,batch_size, contrastiveLoss, accuracy ,time)
path = exp_name+".pth"
model_test = torch.load(path)
"""
def controlNormalize(self):
#controlla se è presente la directory, altrimenti la crea
createFolder(self.path)
#print("Controll")
if not os.path.exists(self.path + '\\dataSetJson.json'):
print("1) Checking: mean, dev_std")
self.run()
else: # se il file esiste controlla se ci sono le key mean e dev
try:
with open(self.path + "\\dataSetJson.json", "r") as json_file:
data = json.load(json_file)
print(self.path + "\\dataSetJson.json")
if not (data.get('normalize') is None):
#print("Qui")
norm = data['normalize']
if not (norm.get('mean') and norm.get('dev_std')) is None:
response = input(
"Do you want to re-calculate the mean and standard deviation? y | n : "
)
if (response == "y"):
print("recalculate")
self.run()
elif (response == "n"):
print("bypass this step!!")
self.mean = tuple(norm['mean'])
print(self.mean)
self.dev_std = tuple(norm['dev_std'])
print(self.dev_std)
self.normalizeDataSet()
return
else:
self.controlNormalize()
else:
self.run()
else:
self.run()
except:
# se il parsing è errato ricalcola la media e
sys.stderr.write("Error parsing")
exit(0)
def controlMargin(self):
#controlla se è presente la directory, altrimenti la crea
createFolder(self.path)
#print("Controll")
if not os.path.exists(self.path + '\\dataSetJson.json'):
print("1) Calculate mean margine")
self.runMargin()
else: # se il file esiste controlla se ci sono le key mean e dev
res = str(self.resize)
try:
with open(self.path + "\\dataSetJson.json", "r") as json_file:
data = json.load(json_file)
print(self.path + "\\dataSetJson.json")
if not (data.get('margineMean_' + res) is None):
#print("Qui")
margin = data['margineMean_' + res]
response = input(
"Do you want to re-calculate margin? y | n : ")
if (response == "y"):
print("recalculate")
self.runMargin()
elif (response == "n"):
print("bypass this step")
self.margin = margin
else:
self.controlMargin()
else:
self.runMargin()
except:
# se il parsing è errato ricalcola la media e
sys.stderr.write("Error parsing")
exit(0)
def main(argv):
#crazione file "dataSet.json" se non esiste
entry = {"nameDB": "Moneys"}
controlFolder("Dataset")
creteFileJson("Dataset\dataSetJson.json", entry)
data_create = DataSetCreate()
#name_id = data_create.name_classes_id()
#list_all_images = data_create.list_all_images()
#num_tot_files = data_create.num_total_file()
parser = argparse.ArgumentParser(description="Dataset Money")
parser.add_argument('--create',
help="datasetBase | datasetLarge | datasetPair")
parser.add_argument(
'--info', help="dataset | datasetBase | datasetLarge | datasetPair")
#parser.add_argument('--training', help="1")
parser.add_argument('--test',
help="Name of model [model5 | model6 ]",
type=str)
parser.add_argument('--train',
help="Name of model [model5 | model6 ]",
type=str)
parser.add_argument('--v', help="version", type=int)
parser.add_argument('--progress',
help="Name of model [model5 | model6 ]",
type=str)
parser.add_argument('--file', help="name file .pth", type=str)
parser.add_argument('--e', help="epoche", type=int)
parser.add_argument('--margine', help="dim of resize", type=int)
parser.add_argument('--classification',
help="[ train | test | continue | demo ]",
type=str)
parser.add_argument('--classtest', help="classTest")
parser.add_argument('--demo', help="[ model5 | model6 ]")
parser.add_argument('--pair', help=" insert id pair [0 - 13824]", type=int)
parser.add_argument('--soglia', help="soglia", type=float)
parser.add_argument('--margin', help="margin", type=float)
parser.add_argument('--path', help="path of model '.pth'", type=str)
parser.add_argument('--distribution',
help="distribuzione dei dati di train allenati")
parser.add_argument('--pathModel',
help="percorso modello da inizializzare")
parser.add_argument('--margin1', help="margine 1", type=float)
parser.add_argument('--margin2', help="margine 2", type=float)
parser.add_argument('--roc', help="roc")
argomento = parser.parse_args()
#-------- DISTRIBUTION------
required_together_distrib = ('distribution', 'v')
if argomento.distribution is not None:
# args.model will be None if v is not provided
if not all([getattr(argomento, x) for x in required_together_distrib]):
raise RuntimeError("Cannot supply --distribution without --v ")
else:
#------ MODEL 6
if argomento.distribution == "model6":
print("DISTRIBUTION model ", argomento.distribution)
#------ MODEL 6 v 2
if argomento.v == 2:
print("version v2")
directory = "Model-6"
version = "2"
resize = 100
batch_size = 16
createFolder(directory)
createFolder(directory + "\\" + version)
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_money_train_loader = DataLoader(pair_train,
batch_size=batch_size,
num_workers=0,
shuffle=True)
path = directory + "\\" + version + "\\modello6_v2_6.pth"
gaussian_distribution_train_margine_single(
directory, version, pair_money_train_loader, resize,
batch_size, path)
else:
exit(0)
#--------------------------- DEMO -------------------------------
required_together_demo = ('demo', 'v', 'pair')
if argomento.demo is not None:
# args.model will be None if v is not provided
if not all([getattr(argomento, x) for x in required_together_demo]):
raise RuntimeError("Cannot supply --demo without --v --pair")
else:
#------ MODEL 5
if argomento.demo == "model5":
print("Demo model ", argomento.demo)
if argomento.v == 5:
print("version v5")
print("model5 v5 ResNet siamese classification SGD")
directory = "Model-5\\"
path = 'modello5_v5.pth'
version = "5"
idPair = argomento.pair
# verifica l'id corrispondente alla coppia se è presente
resize = 100
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
siamese_test = torch.load(path)
demo_obj.test_demo(dizionario, siamese_test)
demo_obj.plottare()
elif argomento.v == 7:
print("version v7")
print(
"DEMO model5 v7, Marek Net siamese classification SGD")
directory = "Model-5\\"
version = "7"
path = directory + version + "\\" + 'modello5_v7_17.pth'
idPair = argomento.pair
# verifica l'id corrispondente alla coppia se è presente
resize = 100
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
siamese_test = torch.load(path)
demo_obj.test_demo(dizionario, siamese_test)
demo_obj.plottare()
else:
print("Versione del model5 non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --train model5 --v [ 5 | 7 ]\n"
)
exit(0)
# --DEMO ---- MODEL 6
elif argomento.demo == "model6":
print("Demo model ", argomento.demo)
#------DEMO--- MODEL 6 v 2
if argomento.v == 2:
print("version v2")
print("model6 v2 ResNet, single margine=2.0, soglia=0.92")
directory = "Model-6\\"
version = "2"
path = directory + version + "\\" + 'modello6_v2_6.pth'
idPair = argomento.pair
resize = 100
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
siamese_test = torch.load(path)
soglia = 0.92
dist = demo_obj.test_demo_single_margine(
dizionario, siamese_test, soglia)
demo_obj.plottare(dist)
elif argomento.v == 4:
print("version v2")
print("model6 v4 ResNet, double margine=0.7 e 1.3")
directory = "Model-6\\"
version = "4"
path = directory + version + "\\" + 'modello6_v4_51.pth'
idPair = argomento.pair
resize = 100
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
siamese_test = torch.load(path)
margin1 = 0.7
margin2 = 1.2
dist = demo_obj.test_demo_double_margine(
dizionario, siamese_test, margin1, margin2)
demo_obj.plottare(dist)
else:
print("Versione del model6 non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --train model6 --v [ 2 | 4 ]\n"
)
exit(0)
else:
print("Modello non riconosciuto")
sys.stderr.write(
"Model not acknowledged, try --train [ model5 | model6 ]\n"
)
exit(0)
# --------------------TRAIN------CLASSIFICAZIONE DEI DATI ---------------------
elif argomento.classification == "train":
required_together = ('classification', 'v', 'e')
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError(
"Cannot supply --classification train without --v --e")
else:
#-------MODEL MNET
if argomento.v == 2:
epochs = 20
lr = 0.0001
momentum = 0.9
batch_size = 16
resize = 100
if argomento.e is not None:
epochs = argomento.e
directory = "Classe"
filename = "//class"
version = "2"
exp_name = 'class_2'
name = 'ModelM'
model = ModelM()
classificazione(directory, filename, version, exp_name, name,
model, lr, epochs, momentum, batch_size,
resize)
#--------MODEL RESNET
elif argomento.v == 1:
print("Resnet")
lr = 0.0001
momentum = 0.9
batch_size = 16
resize = 256
if argomento.e is not None:
epochs = argomento.e
directory = "Classe"
filename = "//class"
version = "1"
exp_name = 'class_1'
name = 'ResNet'
model = resnet34(pretrained=True)
resnet_copy = deepcopy(model)
### adattamento
num_class = 5
resnet_copy.fc = nn.Linear(512, num_class)
resnet_copy.num_classes = num_class
print(resnet_copy)
classificazione(directory, filename, version, exp_name, name,
resnet_copy, lr, epochs, momentum, batch_size,
resize)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --classification train --v [ 1 | 2 ]\n"
)
exit(0)
#-------------------TEST ------CLASSIFICAZIONE DEI DATI
#---- test su data set di base
elif argomento.classification == "test":
required_together = ('classification', 'v')
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError(
"Cannot supply --classification test without --v")
else:
if argomento.v == 2:
print("MNet classification version 2")
directory = "Classe"
version = "2"
batch_size = 16
resize = 100
name = 'ModelM'
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//2//class_2_44.pth'
testing_classificazione(directory, path_dict, version, resize,
batch_size)
elif argomento.v == 1:
print("Resnet classification version 1")
directory = "Classe"
version = "1"
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//1//class_1_19.pth'
name = 'ResNet'
batch_size = 4
resize = 256
testing_classificazione(directory, path_dict, version, resize,
batch_size)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --classification test --v [ 1 | 2 ]\n"
)
exit(0)
#---------------TEST su datasetPair con classificazione Manuale
elif argomento.classification == "testPair":
required_together = ('classification', 'v')
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError(
"Cannot supply --classification testPair without --v")
else:
if argomento.v == 2:
directory = "Classe"
version = "2"
batch_size = 16
resize = 100
name = 'ModelM'
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//2//class_2_44.pth'
testing_classificazionePair(directory, path_dict, version,
resize, batch_size)
elif argomento.v == 1:
print("Resnet classification version 1")
directory = "Classe"
version = "1"
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//1//class_1_19.pth'
name = 'ResNet'
batch_size = 4
resize = 256
testing_classificazionePair(directory, path_dict, version,
resize, batch_size)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --classification testPair --v [ 1 | 2 ]\n"
)
exit(0)
#-------------------CONTINUE ------CLASSIFICAZIONE DEI DATI
elif argomento.classification == "continue":
required_together = ('classification', 'v', 'e')
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError(
"Cannot supply --classification continue without --v --e")
else:
if argomento.v == 2:
print("MNet classification continue version 2")
directory = "Classe"
exp_name = 'class_2'
version = "2"
lr = 0.0001
momentum = 0.9
batch_size = 16
resize = 100
name = 'ModelM'
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//2//class_2_19.pth'
model = torch.load(path_dict)
epoche_avanza = argomento.e
continue_classificazione(directory, model, version, exp_name,
name, lr, momentum, resize,
batch_size, epoche_avanza)
elif argomento.v == 1:
print("Resnet classification continue version 1")
directory = "Classe"
version = "1"
batch_size = 4
resize = 256
lr = 0.0001
momentum = 0.9
exp_name = 'class_1'
name = 'ResNet'
if argomento.pathModel is not None:
path_dict = argomento.pathModel
else:
path_dict = 'Classe//1//class_1_19.pth'
model = torch.load(path_dict)
epoche_avanza = argomento.e
continue_classificazione(directory, model, version, exp_name,
name, lr, momentum, resize,
batch_size, epoche_avanza)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --classification continue --v [ 1 | 2 ]\n"
)
exit(0)
# --------------- DEMO ------------------CLASSIFICAZIONE MANUAL
elif argomento.classification == "demo":
required_together = ('classification', 'v', 'pair')
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError(
"Cannot supply --classification demo without --v --pair")
else:
#----- MODEL RESNET
if argomento.v == 1:
print("Classification Manual ResNet")
if argomento.pathModel is not None:
path = argomento.pathModel
else:
path = 'Classe\\1\\class_1_19.pth'
directory = "Classe\\"
version = "1"
idPair = argomento.pair
resize = 256
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
class_test = torch.load(path)
demo_obj.test_demo_order_manual(dizionario, class_test)
demo_obj.plottare()
#----- MODEL MNET
elif argomento.v == 2:
directory = "Classe\\"
if argomento.pathModel is not None:
path = argomento.pathModel
else:
path = 'Classe\\2\\class_2_44.pth'
version = "2"
idPair = argomento.pair
# verifica l'id corrispondente alla coppia se è presente
resize = 100
demo_obj = Demo(directory, version, resize)
demo_obj.controlPair(idPair)
demo_obj.read_normalize()
dizionario = demo_obj.getitem(idPair)
class_test = torch.load(path)
demo_obj.test_demo_order_manual(dizionario, class_test)
demo_obj.plottare()
return
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --classification demo --v [ 1 | 2 ]\n"
)
exit(0)
#------------ CREAZIONE DEI DATASET --create
if argomento.create == "datasetBase": # creazione dataset di Base
data_create.create_Dataset_Base()
elif argomento.create == "datasetLarge": # creazione dataset di Base e datasetLarge
data_create.create_Dataset_Large()
elif argomento.create == "datasetPair":
# controlla se è presente il dataset splittato
controlFileCSV()
dataSetPair = DataSetPairCreate()
dataSetPair.controlNormalize()
#------------- INFORMAZIONI SUI DATASET --info
data_set_info = argomento.info
if (data_set_info == "dataset"):
#oggetto DataSetCreate
print("Dataset of base\n")
#lettura da file Dataset\dataSetJson.json
info = readFileDataset("Dataset\dataSetJson.json", "dataset")
#info = data_create.info_classes()
for i in info:
print(i)
num = lengthDataset("Dataset\dataSetJson.json", "dataset",
"num_images")
print("Length Dataset of Base = ", num)
print("\n")
elif (data_set_info == "datasetBase"):
print("Dataset Base\n")
#info = data_create.info_datasetLarge()
info = readFileDataset("Dataset\dataSetJson.json", "datasetBase")
for i in info:
print(i)
num = lengthDataset("Dataset\dataSetJson.json", "datasetBase",
"num_sample")
print("Length DatasetBase = ", num)
elif (data_set_info == "datasetLarge"):
print("Dataset Large\n")
#info = data_create.info_datasetLarge()
info = readFileDataset("Dataset\dataSetJson.json", "datasetLarge")
for i in info:
print(i)
num = lengthDataset("Dataset\dataSetJson.json", "datasetLarge",
"num_sample")
print("Length DatasetLarge = ", num)
elif (data_set_info == "datasetPair"):
print("DatasetPair\n")
info = readFileDataset("Dataset\dataSetJson.json", "dataSetPair")
for i in info:
print(i)
#--------------FASE TRAINING OF MODEL 5 and 6 --train
required_together = ('train', 'v', 'e')
if argomento.train is not None:
if not all([getattr(argomento, x) for x in required_together]):
raise RuntimeError("Cannot supply --train without --v --e")
else:
#------ MODEL 5
if argomento.train == "model5":
if argomento.v == 7:
# siamese con trasfer-learning Mnet usata pe rla classigìficazione
# tolto il livello per la classificazione a 2 classi
# nuovo- inizializzazione class_2 epoche 44
lr = 0.0001
momentum = 0.9
resize = 100
epochs = 20
if argomento.e is not None:
epochs = argomento.e
batch_size = 4
directory = "Model-5"
filename = "//5_v7"
version = "7"
exp_name = 'modello5_v7'
name = 'MNet'
#inizializzazione del modello con parametri di MNet
path = "class_2.pth"
model = torch.load(path)
model_copy = deepcopy(model)
fully_connect = model_copy.fc
fully = list(fully_connect)
fully.pop()
model_copy.fc = nn.Sequential(*fully)
# adattamento
model_copy.fc2 = nn.Sequential(nn.Linear(512, 2))
print(model_copy)
train_model_class_v1(directory, filename, version,
exp_name, name, model_copy, lr,
epochs, momentum, batch_size, resize)
elif argomento.v == 5:
# siamese con trasfer-learning Resnet usato per la classificazione
# e tolto l'ultimo livello
# aggiunto per prendere in ingresso la concatenazione degli output
# e aggiunto il livello per la classificazione a 2 classi
# la loss function è la CrossEntropy per la classificazione 0 e 1
lr = 0.0001
momentum = 0.9
resize = 100
epochs = 20
if argomento.e is not None:
epochs = argomento.e
batch_size = 4
decay = 0.0004
directory = "Model-5"
filename = "//5_v5"
version = "5"
exp_name = 'modello5_v5'
name = 'ResNet_Class'
# inizializzazione
model = torch.load("class_1.pth")
model_copy = deepcopy(model)
### adattamento
num_class = 256
model_copy.fc = nn.Linear(512, num_class)
model_copy.num_classes = num_class
print(model_copy)
model_copy.fc2 = nn.Sequential(nn.Linear(512, 2))
print(model_copy)
train_model_class_v1(directory,
filename,
version,
exp_name,
name,
model_copy,
lr,
epochs,
momentum,
batch_size,
resize,
decay=decay,
modeLoss=None,
dizionario_array=None)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --train model5 --v [ 5 | 7 ]\n"
)
exit(0)
#-----train MODEL6 siamese
elif argomento.train == "model6":
#----- Resnet - single margine
if argomento.v == 2:
# siamese con trasfer-learning Resnet usato per la classificazione
# e tolto il livello per la classivicazione a 5 classi
# e inserito quello da 256
#
# la loss function è la Contrastive loss , margine
decay = 0.0004
lr = 0.0001
momentum = 0.9
resize = 100
epochs = 20
if argomento.e is not None:
epochs = argomento.e
batch_size = 4
directory = "Model-6"
filename = "//6_v2"
version = "2"
exp_name = 'modello6_v2'
name = 'RestNet_Margine'
# Usato per la classificazione a 5 classi, fine-tuning Resnet34
model = torch.load("class_1.pth")
model_copy = deepcopy(model)
### adattamento
num_class = 256
model_copy.fc = nn.Linear(512, num_class)
model_copy.num_classes = num_class
print(model_copy)
train_model_margine(directory,
filename,
version,
exp_name,
name,
model_copy,
lr,
epochs,
momentum,
batch_size,
resize,
decay=decay,
margin=2.0,
soglia=1.0,
modeLoss="single")
elif argomento.v == 4:
# siamese con trasfer-learning Resnet usato per la classificazione
# e tolto il livello per la classivicazione a 5 classi
# e inserito quello da 256
# la loss function è la Contrastive loss , double margine
decay = 0.004
lr = 0.0001
momentum = 0.9
resize = 100
epochs = 20
if argomento.e is not None:
epochs = argomento.e
batch_size = 4
directory = "Model-6"
filename = "//6_v4"
version = "4"
exp_name = 'modello6_v4'
name = 'RestNet_Margine_Double'
model = torch.load(
"class_1.pth"
) # Usato per la classificazione fine-tuning Resnet
model_copy = deepcopy(model)
# serve per rimuovere l'ultimo livello"
### adattamento
num_class = 256
model_copy.fc = nn.Linear(512, num_class)
model_copy.num_classes = num_class
print(model_copy)
margin1 = 0.7
margin2 = 1.2
if argomento.margin1 is not None:
margin1 = argomento.margin1
if argomento.margin2 is not None:
margin2 = argomento.margin2
train_model_margine_double(directory,
filename,
version,
exp_name,
name,
model_copy,
lr,
epochs,
momentum,
batch_size,
resize,
decay=decay,
margin1=margin1,
margin2=margin2,
modeLoss="double")
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --train model6 --v [ 2 | 4 ]\n"
)
exit(0)
else:
print("Modello non riconosciuto ")
sys.stderr.write(
"Model not acknowledged, try --train [model5 | model6 ]\n")
exit(0)
#--------------FASE TESTING --test
required_together_test = ('test', 'v')
if argomento.test is not None:
if not all([getattr(argomento, x) for x in required_together_test]):
raise RuntimeError("Cannot supply --test without --v")
else:
#------ test MODEL 5
if argomento.test == "model5":
# ----------model 5 v 5 ---- ResNet
if argomento.v == 5:
print("version", argomento.v)
print("model 5 v5 ResNet classi siamese con lr =0.0001 ")
directory = "Model-5\\"
path = 'modello5_v5.pth'
version = "5"
batch_size = 16
resize = 100
test_model_class(directory,
path,
version,
resize,
batch_size,
margine=None)
elif argomento.v == 7:
# ----------model 5 v 7 ---- MNet
print("version", argomento.v)
print("model 5 v7 MNet classi siamese con lr =0.0001")
directory = "Model-5\\"
path = 'Model-5\\7\\modello5_v7_17.pth'
version = "7"
batch_size = 16
resize = 100
test_model_class(directory,
path,
version,
resize,
batch_size,
margine=None)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --test model5 --v [ 5 | 7 ]\n"
)
exit(0)
#----------test MODEL 6
elif argomento.test == "model6":
#------ model test 6 v 2
if argomento.v == 2:
print("version", argomento.v)
print(
"model6 v2 Test ResNet siamese margine one 2.0 soglia 0.92"
)
directory = "Model-6\\"
path = directory + "2\\" + 'modello6_v2_6.pth'
version = "2"
soglia = 0.92
if argomento.soglia is not None:
soglia = argomento.soglia
batch_size = 16
resize = 100
print("Soglia", soglia)
test_model_margine(directory,
path,
version,
resize,
batch_size,
margine=soglia)
#-------- model test 6 v 4
elif argomento.v == 4:
print("version", argomento.v)
print(
"model6 v 4 Test ResNet siamese margine double 0.7 e 1.2, numero epoche 52 "
)
directory = "Model-6\\"
path = directory + "4\\" + 'modello6_v4_51.pth'
version = "4"
margin1 = 0.7
margin2 = 1.2
batch_size = 16
resize = 100
test_model_margine_double(directory, path, version, resize,
batch_size, margin1, margin2)
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --test model6 --v [ 2 | 4 ]\n"
)
exit(0)
else:
print("Modello non riconosciuto")
sys.stderr.write(
"Model not acknowledged, try --test [model5 | model6 ]\n")
exit(0)
# ---------------------PERFORMANCE
if argomento.roc is not None:
print(argomento.roc)
print(argomento.v)
# PERFORMANCE MODEL 6 V 2
if argomento.roc == "model6":
# model test 6 v 2
if argomento.v == 2:
print("version", argomento.v)
print(
"model6 v2 Test ResNet siamese margine one 2.0 soglia 1.0")
directory = "Model-6"
version = "2"
path = directory + "\\" + version + '\\modello6_v2_6.pth'
version = "2"
batch_size = 16
resize = 100
test_model_performance(directory, path, version, resize,
batch_size)
#--------------FASE CONTINUE --continue
required_together_continue = ('progress', 'v', 'e')
# args.model will be None if v is not provided
if argomento.progress is not None:
if not all([getattr(argomento, x)
for x in required_together_continue]):
raise RuntimeError("Cannot supply --progress without --v --e")
else:
#----- MODEL 6
if argomento.progress == "model6":
print("model", argomento.progress)
# model continue 6 v 2
if argomento.v == 2:
# siamese con trasfer-learning Resnet usato per la classificazione
# e tolto il livello per la classivicazione a 5 classi
# e inserito quello da 256
# la loss function è la Contrastive loss , margine single
decay = 0.0004
lr = 0.0001
momentum = 0.9
resize = 100
batch_size = 4
directory = "Model-6"
filename = "//6_v2"
version = "2"
exp_name = 'modello6_v2'
name = 'RestNet_Margine_Single'
if argomento.pathModel is not None:
path = argomento.pathModel
else:
path = 'Model-6//2//modello6_v2_13.pth'
model = torch.load(path)
epoche_avanza = argomento.e
continue_model_margine_single(directory,
filename,
version,
exp_name,
name,
model,
lr,
epoche_avanza,
momentum,
batch_size,
resize,
decay=decay,
margin1=2.0,
soglia=0.92,
modeLoss="single")
# model continue 6 v 4
elif argomento.v == 4:
# siamese con trasfer-learning Resnet usato per la classificazione
# e tolto il livello per la classivicazione a 5 classi
# e inserito quello da 256
# la loss function è la Contrastive loss , margine double
decay = 0.004
lr = 0.0001
momentum = 0.9
resize = 100
batch_size = 4
directory = "Model-6"
filename = "//6_v4"
version = "4"
exp_name = 'modello6_v4'
name = 'RestNet_Margine_Double'
if argomento.pathModel is not None:
path = argomento.pathModel
else:
path = 'Model-6//4//modello6_v4_56.pth'
model = torch.load(path)
margin1 = 0.7
margin2 = 1.2
if argomento.margin1 is not None:
margin1 = argomento.margin1
if argomento.margin2 is not None:
margin2 = argomento.margin2
epoche_avanza = argomento.e
continue_model_margine_double(directory,
filename,
version,
exp_name,
name,
model,
lr,
epoche_avanza,
momentum,
batch_size,
resize,
decay=decay,
margin1=margin1,
margin2=margin2,
modeLoss="double")
# model continue 6 v 6
elif argomento.v == 6:
decay = 0.02
lr = 0.001
momentum = 0.9
resize = 100
batch_size = 4
directory = "Model-6"
filename = "//6_v6"
version = "6"
exp_name = 'modello6_v6'
name = 'RestNet_Margine_Double'
if argomento.pathModel is not None:
path = argomento.pathModel
else:
path = 'Model-6//4//modello6_v4_51.pth'
model = torch.load(path)
margin1 = 0.7
margin2 = 1.2
if argomento.margin1 is not None:
margin1 = argomento.margin1
if argomento.margin2 is not None:
margin2 = argomento.margin2
epoche_avanza = argomento.e
continue_model_margine_double(directory,
filename,
version,
exp_name,
name,
model,
lr,
epoche_avanza,
momentum,
batch_size,
resize,
decay=decay,
margin1=margin1,
margin2=margin2,
modeLoss="double")
else:
print("Versione non riconosciuta")
sys.stderr.write(
"Version not acknowledged, try --progress model6 --v [ 2 | 4 | 6 ]\n"
)
exit(0)
else:
print("Modello non riconosciuto ")
sys.stderr.write(
"Model not acknowledged, try --progress [ model6 ]\n")
exit(0)
def train_model_margine_dynamik(directory, filename, version, exp_name, name,
model, lr, epochs, momentum, batch_size,
resize):
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_test = dataSetPair.pair_money_test
pair_validation = dataSetPair.pair_money_val
pair_money_train_loader = DataLoader(pair_train,
batch_size=batch_size,
num_workers=0,
shuffle=True)
pair_money_test_loader = DataLoader(pair_test,
batch_size=batch_size,
num_workers=0)
pair_money_val_loader = DataLoader(pair_validation,
batch_size=batch_size,
num_workers=0)
#training
#modello, tempo di training, loss su train, loss su val
createFolder(directory + "\\" + version)
writeJsonModelInit1(directory, name, version)
print("Training...")
modello, f, last_loss_train, last_loss_val, last_acc_train, last_acc_val = train_margine_dynamik(
directory,
version,
model,
pair_money_train_loader,
pair_money_val_loader,
resize,
batch_size,
exp_name,
lr=lr,
epochs=epochs)
print("Time computing", f)
print("last_loss_train", last_loss_train)
print("last_loss_val", last_loss_val)
print("last_acc_train", last_acc_train)
print("last_acc_val", last_acc_val)
hyperparametr = {
"indexEpoch": epochs - 1,
"lr": lr,
"momentum": momentum,
"numSampleTrain": len(pair_train)
}
contrastiveLoss = {
"lossTrain": last_loss_train,
"lossValid": last_loss_val
}
accuracy = {"accuracyTrain": last_acc_train, "accuracyValid": last_acc_val}
time = {"training": f}
writeJsonModelClass(directory, name, version, hyperparametr, resize,
batch_size, contrastiveLoss, accuracy, time)
namep = exp_name + ".pth"
siamese_model = torch.load(namep)
print("Testing on Validation set")
timeVal, pair_prediction_val, pair_label_val = test_margine_dynamik(
siamese_model, pair_money_val_loader)
numSimilPredette = np.sum(pair_prediction_val == 0)
print("Num Simili predette", numSimilPredette)
numDissimilPredette = np.sum(pair_prediction_val == 1)
print("Num Dissimil predette", numDissimilPredette)
numSimilReali = np.sum(pair_label_val == 0)
print("Num Simili Reali", numSimilReali)
numDissimilReali = np.sum(pair_label_val == 1)
print("Num Dissimil Reali", numDissimilReali)
#calculate Accuracy
print(pair_prediction_val[0:10])
print(pair_label_val[0:10])
accuracyVal = accuracy_score(pair_label_val, pair_prediction_val)
print("Accuarcy di test: %0.4f" % accuracyVal)
#calculate Precision
precisionVal = precision_score(pair_label_val, pair_prediction_val)
print("Precision di test: %0.4f" % precisionVal)
#calculate Recall
recallVal = recall_score(pair_label_val, pair_prediction_val)
print("Recall di test: %0.4f" % recallVal)
#calculate F1 score
if recallVal != 0.0 and precisionVal != 0.0:
scores_testing_val = f1_score(pair_label_val,
pair_prediction_val,
average=None)
scores_testing_val = scores_testing_val.mean()
print("mF1 score di testing: %0.4f" % scores_testing_val)
else:
scores_testing_val = 0.000
print("mscoref1", scores_testing_val)
key = ["accuracy", "precision", "recall", "mf1_score", "time"]
entry = [
"accuracyVal", "precisionVal", "recallVal", "f1_score_Val", "testVal"
]
value = [accuracyVal, precisionVal, recallVal, scores_testing_val, timeVal]
addValueJsonModel(directory + "modelTrained.json", version, key[0],
entry[0], value[0])
addValueJsonModel(directory + "modelTrained.json", version, key[1],
entry[1], value[1])
addValueJsonModel(directory + "modelTrained.json", version, key[2],
entry[2], value[2])
addValueJsonModel(directory + "modelTrained.json", version, key[3],
entry[3], value[3])
addValueJsonModel(directory + "modelTrained.json", version, key[4],
entry[4], value[4])
def train_model_margine_double(directory,
filename,
version,
exp_name,
name,
model,
lr,
epochs,
momentum,
batch_size,
resize,
decay=None,
margin1=None,
margin2=None,
modeLoss=None):
# directory es "Model-6"
createFolder(directory)
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_test = dataSetPair.pair_money_test
pair_validation = dataSetPair.pair_money_val
pair_money_train_loader = DataLoader(pair_train,
batch_size=batch_size,
num_workers=0,
shuffle=True)
pair_money_test_loader = DataLoader(pair_test,
batch_size=batch_size,
num_workers=0)
pair_money_val_loader = DataLoader(pair_validation,
batch_size=batch_size,
num_workers=0)
siamese_money = model # modello
createFolder(directory + "\\" + version)
createFolder(directory + "\\" + version + "\\" + "Metod2")
writeJsonModelInit1(directory, name, version)
print("Training...")
modello, f, last_loss_train, last_loss_val, last_acc_train, last_acc_val = train_siamese_margin_double(
directory,
version,
siamese_money,
pair_money_train_loader,
pair_money_val_loader,
resize,
batch_size,
exp_name=exp_name,
lr=lr,
epochs=epochs,
momentum=momentum,
margin1=margin1,
margin2=margin2,
logdir='logs',
decay=decay,
modeLoss=modeLoss)
print("Time computing", f)
print("last_loss_train", last_loss_train)
print("last_loss_val", last_loss_val)
print("last_acc_train", last_acc_train)
print("last_acc_val", last_acc_val)
if not decay is None:
hyperparametr = {
"indexEpoch": epochs - 1,
"lr": lr,
"decay": decay,
"momentum": momentum,
"numSampleTrain": len(pair_train)
}
else:
hyperparametr = {
"indexEpoch": epochs - 1,
"lr": lr,
"momentum": momentum,
"numSampleTrain": len(pair_train)
}
contrastiveLoss = {
"lossTrain": last_loss_train,
"lossValid": last_loss_val
}
accuracy = {"accuracyTrain": last_acc_train, "accuracyValid": last_acc_val}
time = {"training": f}
writeJsonModelClass(directory, name, version, hyperparametr, resize,
resize, batch_size, contrastiveLoss, accuracy, time)
def train_model(directory,
filename,
version,
exp_name,
name,
model,
lr,
epochs,
momentum,
batch_size,
resize,
modeLoss=None):
warnings.filterwarnings('always')
directory = directory
version = version
lr = lr
epochs = epochs
momentum = momentum
batch_size = batch_size
resize = resize
controlFileCSV()
controlFileCSVPair()
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_test = dataSetPair.pair_money_test
pair_validation = dataSetPair.pair_money_val
pair_money_train_loader = DataLoader(pair_train,
batch_size=batch_size,
num_workers=0,
shuffle=True)
pair_money_test_loader = DataLoader(pair_test,
batch_size=batch_size,
num_workers=0)
pair_money_val_loader = DataLoader(pair_validation,
batch_size=batch_size,
num_workers=0)
siamese_money = model # modello
#training
#modello, tempo di training, loss su train, loss su val
print("Training...")
siamese_money, timeTraining, array_loss_train, array_loss_val, array_sample_train, array_sample_valid, array_acc_train, array_acc_valid, labels_train, prediction_train, labels_val, prediction_val = train_siamese(
siamese_money,
pair_money_train_loader,
pair_money_val_loader,
exp_name,
lr=lr,
epochs=epochs,
modeLoss=modeLoss)
print("time Training\n ", timeTraining)
print("Loss last on train", array_loss_train[-1])
print("Loss last on valid\n", array_loss_val[-1])
print("Array sample last on train", array_sample_train[-1])
print("Array sample on last valid\n", array_sample_valid[-1])
print("lunghezza array accuracy TRAIN", len(array_acc_train))
print("Lunghezza array SAMPLE train", len(array_sample_train))
print("lunghezza array accuracy VALID", len(array_acc_valid))
print("Lunghezza array SAMPLE VALID", len(array_sample_valid))
#controlla se è presente la directory, altrimenti la crei
createFolder(directory)
#plot
plotLoss(directory, filename, array_loss_train, array_loss_val,
array_sample_train, array_sample_valid)
plotAccuracy(directory, filename, array_acc_train, array_acc_valid,
array_sample_train, array_sample_valid)
#------------------------TESTARE SU DATI DEL TRAIN
#device = "cuda" if torch.cuda.is_available() else "cpu"
#siamese_money.to(device)
print("Score on dataTrain...")
#pair_predictionTrain, pair_labelTrain , timeTrain = test_siamese(siamese_money, pair_money_train_loader, margin=2 )
#calculate Accuracy
accuracyTrain = accuracy_score(labels_train, prediction_train)
print("Accuarcy di train of last batch: %0.4f" % accuracyTrain)
#calculate Precision
precisionTrain = precision_score(labels_train, prediction_train)
print("Precision di of last batch train: %0.4f" % precisionTrain)
#calculate Recall
recallTrain = recall_score(labels_train, prediction_train)
print("Recall of last batch di train: %0.4f" % recallTrain)
if recallTrain != 0.0 and precisionTrain != 0.0:
#calculate F1 score
scores_training = f1_score(labels_train,
prediction_train,
average=None)
scores_training = scores_training.mean()
print("F1 score of last bacth di train: %0.4f" % scores_training)
else:
scores_training = 0.000
print("F1 score of last bacth di train: %0.4f" % scores_training)
#------------------------TESTARE SU DATI DEL VALID
print("Score on dataValid...")
#pair_predictionValid, pair_labelValid , timeValid = test_siamese(siamese_money, pair_money_val_loader, margin=2 )
#calculate Accuracy
accuracyValid = accuracy_score(labels_val, prediction_val)
print("Accuarcy di validation: %0.4f" % accuracyValid)
#calculate Precision
precisionValid = precision_score(labels_val, prediction_val)
print("Precision di validation: %0.4f" % precisionValid)
#calculate Recall
recallValid = recall_score(labels_val, prediction_val)
print("Recall di validation: %0.4f" % recallValid)
#calculate F1 score
if recallValid != 0.0 and recallTrain != 0.0:
scores_valid = f1_score(labels_val, prediction_val, average=None)
scores_valid = scores_valid.mean()
print("mF1 score di validation: %0.4f" % scores_valid)
else:
scores_valid = 0.00
print("mF1 score di validation: %0.4f" % scores_valid)
""" QUESTO VA FATTO IN FASE DI TESTING UTILIZZANDO I DATI DEL TEST E IL COMANDO RELOAD
#------------------------TESTARE SU DATI DEL TEST
print("Testing on dataTest....")
pair_prediction, pair_label, timeTest = test_siamese(siamese_money, pair_money_test_loader, margin=2 )
#calculate Accuracy
accuracyTest = accuracy_score(pair_label, pair_prediction)
print("Accuarcy di test: %0.4f"% accuracyTest)
#calculate Precision
precisionTest = precision_score(pair_label, pair_prediction)
print("Precision di test: %0.4f"% precisionTest)
#calculate Recall
recallTest = recall_score(pair_label, pair_prediction)
print("Recall di test: %0.4f"% recallTest)
#calculate F1 score
scores_testing = f1_score(pair_label,pair_prediction, average=None)
print("F1 score di testing: %0.4f"% scores_testing)
"""
#-------------------------
hyperparametr = {
"indexEpoch": epochs - 1,
"lr": lr,
"momentum": momentum,
"numSampleTrain": len(pair_train)
}
contrastiveLoss = {
"lossTrain": array_loss_train[-1],
"lossValid": array_loss_val[-1]
}
accuracy = {"accuracyTrain": accuracyTrain, "accuracyValid": accuracyValid}
precision = {
"precisionTrain": precisionTrain,
"precisionValid": precisionValid
}
recall = {"recallTrain": recallTrain, "recallValid": recallValid}
f1score = {
"f1_score_Train": scores_training,
"f1_score_Valid": scores_valid
}
time = {"training": timeTraining}
writeJsonModel(directory, name, version, hyperparametr, batch_size,
contrastiveLoss, accuracy, f1score, precision, recall, time)
def continue_classificazione(directory,model,version,exp_name,name,lr, momentum,resize,batch_size, epoche_avanza):
createFolder(directory)
createFolder(directory+"\\"+version)
controlFileCSVBase()
dataSetClass = DatasetClassi(resize)
dataSetClass.controlNormalize()
train = dataSetClass.dataset_train_norm
validation = dataSetClass.dataset_valid_norm
test = dataSetClass.dataset_test_norm
money_train_loader = DataLoader(train, batch_size=batch_size, num_workers=0, shuffle=True)
money_test_loader = DataLoader(test, batch_size=batch_size, num_workers=0)
money_val_loader = DataLoader(validation , batch_size = batch_size, num_workers=0)
epoche_fatte =0
array_loss_train=[]
array_loss_valid=[]
array_accuracy_train=[]
array_accuracy_valid=[]
array_glb_train=[]
array_glb_valid=[]
percorso1 = directory+"//"+"modelTrained.json"
with open(percorso1,"r") as file:
data = json.load(file)
if not( data.get(version) is None):
obj = data[version]
if not(obj.get("hyperparametr") is None):
para = obj["hyperparametr"]
if not(para.get("indexEpoch") is None):
epoche_fatte = para["indexEpoch"]
if not(obj.get("time") is None):
tempo = obj["time"]
if not(tempo.get("training") is None):
tempoTrain = tempo["training"]
percorso2= directory+"//"+version+"//"+"value_arrays.json"
with open(percorso2,"r") as file2:
data2 = json.load(file2)
if not( data2.get("array_loss_train") is None):
array_loss_train = data2["array_loss_train"]
if not( data2.get("array_loss_valid") is None):
array_loss_valid = data2["array_loss_valid"]
if not( data2.get("array_accuracy_train") is None):
array_accuracy_train = data2["array_accuracy_train"]
if not( data2.get("array_accuracy_valid") is None):
array_accuracy_valid = data2["array_accuracy_valid"]
if not( data2.get("array_glb_train") is None):
array_glb_train = data2["array_glb_train"]
if not( data2.get("array_glb_valid") is None):
array_glb_valid = data2["array_glb_valid"]
print("Indice epoca gia fatta: ",epoche_fatte)
print("Epoche avanza :",epoche_avanza)
print("Array loss train ", array_loss_train)
print("Array loss valid", array_loss_valid)
print("Array accuracy train", array_accuracy_train)
print("Array accuracy valid", array_accuracy_valid)
print("Array glb train", array_glb_train)
print("array glb valid ", array_glb_valid)
epochs = epoche_fatte + epoche_avanza + 1
dizionario_array = {"epoche_fatte":epoche_fatte, "epoche_avanza":epoche_avanza,"l_train": array_loss_train, "l_valid": array_loss_valid, "a_train":array_accuracy_train,"a_valid":array_accuracy_valid, "g_train":array_glb_train, "g_valid":array_glb_valid, "tempoTrain":tempoTrain }
modello ,f, last_loss_train, last_loss_val, last_acc_train, last_acc_val=train_class(directory,version, model, money_train_loader, money_val_loader,resize, batch_size, exp_name , lr=lr, epochs = epochs, dizionario = dizionario_array)
print("Time computing", f)
tempo1 = float(tempoTrain)
tempo2 = float(f)
tempo = tempo1+tempo2
f =str(tempo)
print("last_loss_train",last_loss_train)
print("last_loss_val",last_loss_val)
print("last_acc_train",last_acc_train)
print("last_acc_val",last_acc_val)
hyperparametr = {"indexEpoch":epochs-1,"lr":lr, "momentum" : momentum, "batchSize":batch_size }
loss = {"lossTrain": last_loss_train, "lossValid":last_loss_val}
accuracy = {"accuracyTrain":last_acc_train , "accuracyValid":last_acc_val }
time = {"training": f}
writeJsonModelClass(directory,name,version, hyperparametr,resize,batch_size, loss, accuracy ,time)
def testing_classificazionePair(directory,path, version,resize,batch_size):
# directory "Classe
model = torch.load(path)
controlFileCSV()
controlFileCSV()
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_test = dataSetPair.pair_money_test
pair_money_test_loader = DataLoader(pair_test, batch_size, num_workers=0)
createFolder(directory)
createFolder(directory+"\\"+version)
timeTest,pair_prediction, pair_label = test_classifierPair(model, pair_money_test_loader)
accuracyTest = accuracy_score(pair_label, pair_prediction)
print("Accuarcy di test: %0.4f"% accuracyTest)
#calculate Precision
precisionTest = precision_score(pair_label, pair_prediction,average='micro')
print("Precision di test: %0.4f"% precisionTest)
#calculate Recall
recallTest = recall_score(pair_label, pair_prediction,average='micro')
print("Recall di test: %0.4f"% recallTest)
#calculate F1 score
if recallTest!= 0.0 and precisionTest != 0.0:
scores_testing = f1_score(pair_label,pair_prediction, average='micro')
scores_testing = scores_testing.mean()
print("mF1 score di testing: %0.4f"% scores_testing)
else:
scores_testing = 0.000
print("mscoref1",scores_testing)
key=["accuracy","precision","recall","mf1_score","time"]
entry=["accuracyTest_Pair","precisionTest_Pair","recallTest_Pair","f1_score_Test_Pair","testing_Pair"]
value=[accuracyTest,precisionTest,recallTest,scores_testing,timeTest]
addValueJsonModel(directory+"\\modelTrained.json",version, key[0] ,entry[0], value[0])
addValueJsonModel(directory+"\\modelTrained.json",version, key[1] ,entry[1], value[1])
addValueJsonModel(directory+"\\modelTrained.json",version, key[2] ,entry[2], value[2])
addValueJsonModel(directory+"\\modelTrained.json",version, key[3] ,entry[3], value[3])
addValueJsonModel(directory+"\\modelTrained.json",version, key[4] ,entry[4], value[4])
print("Classification Report")
print(classification_report(pair_label, pair_prediction))
cm = confusion_matrix(pair_label, pair_prediction)
print("Matrice di confusione \n",cm)
print("\n")
#"--------
FP = cm.sum(axis=0) - np.diag(cm)
FN = cm.sum(axis=1) - np.diag(cm)
TP = np.diag(cm)
TN = cm.sum() - (FP + FN + TP)
FP = FP.astype(float)
FN = FN.astype(float)
TP = TP.astype(float)
TN = TN.astype(float)
# Sensitivity, hit rate, recall, or true positive rate
TPR = TP/(TP+FN)
# Specificity or true negative rate
TNR = TN/(TN+FP)
# Precision or positive predictive value
PPV = TP/(TP+FP)
# Negative predictive value
NPV = TN/(TN+FN)
# Fall out or false positive rate
FPR = FP/(FP+TN)
# False negative rate
FNR = FN/(TP+FN)
# False discovery rate
FDR = FP/(TP+FP)
print("\n")
print("TNR:",TNR)
print("FPR:",FPR)
print("FNR:",FNR)
print("TPR:",TPR)
#----------------
cm.sum(1).reshape(-1,1)
cm=cm/cm.sum(1).reshape(-1,1) #il reshape serve a trasformare il vettore in un vettore colonna
print("\n")
print("Matrice di confusione normalizzata \n",cm)
"""
tnr, fpr, fnr, tpr = cm.ravel()
print("\n")
print("TNR:",tnr)
print("FPR:",fpr)
print("FNR:",fnr)
print("TPR:",tpr)
"""
key = "performance_test_Pair"
entry=["TNR","FPR","FNR","TPR"]
value=[list(TNR), list(FPR), list(FNR), list(TPR)]
addValueJsonModel(directory+"\\modelTrained.json",version, key ,entry[0], value[0])
addValueJsonModel(directory+"\\modelTrained.json",version, key ,entry[1], value[1])
addValueJsonModel(directory+"\\modelTrained.json",version, key ,entry[2], value[2])
addValueJsonModel(directory+"\\modelTrained.json",version, key ,entry[3], value[3])
def continue_model_margine_single( directory,filename,version, exp_name,name,model, lr,epoche_avanza ,momentum,batch_size,resize,decay=None,margin1=2.0,soglia=0.92, modeLoss="single"):
createFolder(directory+"\\"+version)
createFolder(directory+"\\"+version+"\\"+"Metod2")
dataSetPair = DataSetPairCreate(resize)
dataSetPair.controlNormalize()
pair_train = dataSetPair.pair_money_train
pair_test = dataSetPair.pair_money_test
pair_validation = dataSetPair.pair_money_val
pair_money_train_loader = DataLoader(pair_train, batch_size=batch_size, num_workers=0, shuffle=True)
pair_money_test_loader = DataLoader(pair_test, batch_size=batch_size, num_workers=0)
pair_money_val_loader = DataLoader(pair_validation , batch_size = batch_size, num_workers=0)
epoche_fatte =0
array_loss_train=[]
array_loss_valid=[]
array_acc_train=[]
array_acc_valid=[]
array_glb_train=[]
array_glb_valid=[]
percorso1 = directory+"//"+"modelTrained.json"
with open(percorso1,"r") as file:
data = json.load(file)
if not( data.get(version) is None):
obj = data[version]
if not(obj.get("hyperparametr") is None):
para = obj["hyperparametr"]
if not(para.get("indexEpoch") is None):
epoche_fatte = para["indexEpoch"]
if not(obj.get("time") is None):
tempo = obj["time"]
if not(tempo.get("training") is None):
tempoTrain = tempo["training"]
percorso2= directory+"//"+version+"//"+"value_arrays.json"
with open(percorso2,"r") as file2:
data2 = json.load(file2)
if not( data2.get("array_loss_train") is None):
array_loss_train = data2["array_loss_train"]
if not( data2.get("array_loss_valid") is None):
array_loss_valid = data2["array_loss_valid"]
if not( data2.get("array_accuracy_train") is None):
array_accuracy_train = data2["array_accuracy_train"]
if not( data2.get("array_accuracy_valid") is None):
array_accuracy_valid = data2["array_accuracy_valid"]
if not( data2.get("array_glb_train") is None):
array_glb_train = data2["array_glb_train"]
if not( data2.get("array_glb_valid") is None):
array_glb_valid = data2["array_glb_valid"]
"""
percorso3= directory+"//"+version+"//"+"Metod2"+"//"+"value_performance.json"
with open(percorso3,"r") as file3:
data3 = json.load(file3)
if not( data3.get("array_acc_valid") is None):
array_acc_valid_2 = data3["array_acc_valid"]
if not( data3.get("array_f1_valid") is None):
array_f1_valid_2 = data3["array_f1_valid"]
if not( data3.get("array_recall_valid") is None):
array_recall_valid_2 = data3["array_recall_valid"]
if not( data3.get("array_precision_valid") is None):
array_precision_valid_2 = data3["array_precision_valid"]
if not( data3.get("array_tp_valid") is None):
array_tp_valid_2 = data3["array_tp_valid"]
if not( data3.get("array_fp_valid") is None):
array_fp_valid_2 = data3["array_fp_valid"]
if not( data3.get("gl_step_valid") is None):
array_glb_valid_2 = data3["gl_step_valid"]
"""
print("Indice epoca gia fatta: ",epoche_fatte)
print("Epoche avanza :",epoche_avanza)
print("Array loss train ", array_loss_train)
print("Array loss valid", array_loss_valid)
print("Array accuracy train", array_accuracy_train)
print("Array accuracy valid", array_accuracy_valid)
print("Array glb train", array_glb_train)
print("array glb valid ", array_glb_valid)
#indice epoca_fatte 19
epochs = epoche_fatte + epoche_avanza + 1
dizionario_array = {"epoche_fatte":epoche_fatte, "epoche_avanza":epoche_avanza,"l_train": array_loss_train, "l_valid": array_loss_valid, "a_train":array_accuracy_train,"a_valid":array_accuracy_valid, "g_train":array_glb_train, "g_valid":array_glb_valid, "tempoTrain":tempoTrain }
modello ,f, last_loss_train, last_loss_val, last_acc_train, last_acc_val= train_siamese_margine(directory,version,model, pair_money_train_loader, pair_money_val_loader,resize,batch_size, exp_name=exp_name,lr=lr, epochs=epochs, momentum=momentum, margin=margin1,soglia=soglia, logdir="logs", decay=decay, modeLoss=modeLoss, dizionario= dizionario_array)
print("Time computing", f)
print("last_loss_train",last_loss_train)
print("last_loss_val",last_loss_val)
print("last_acc_train",last_acc_train)
print("last_acc_val",last_acc_val)
if not decay is None:
hyperparametr = {"indexEpoch":epochs-1,"lr":lr,"decay":decay, "momentum" : momentum, "numSampleTrain": len(pair_train), "soglia":soglia, "soglia":soglia }
else:
hyperparametr = {"indexEpoch":epochs-1,"lr":lr, "momentum" : momentum, "numSampleTrain": len(pair_train),"margin1":margin1, "soglia":soglia}
contrastiveLoss = {"lossTrain": last_loss_train, "lossValid":last_loss_val}
accuracy = {"accuracyTrain":last_acc_train , "accuracyValid":last_acc_val }
time = {"training": f}
writeJsonModelClass(directory,name,version, hyperparametr,resize, batch_size, contrastiveLoss, accuracy ,time)
