def main():
# Séparer les données et leur cibles
g_donnees = gd.GestionDonnees(d_base)
[types, X, t] = g_donnees.lecture_donnees(d_base)
# Séparer les données pour test et train
x_tr, x_ts, t_tr, t_ts = g_donnees.sep_donnees(X, t)
# Entraînement
debut_e = time.time(
) # Heure de debut pour mesurer le temps d'entraînement
classif.entrainement(x_tr, t_tr, cherche_hyp)
fin_e = time.time() # Heure de fin pour mesurer le temps d'entraînement
print(
'Fin de l\'entrainement. Réalisé en %.2f secondes.' %
(fin_e - debut_e), '\n')
# Prédictions pour les ensembles d'entraînement et de test
predict_tr = classif.prediction(x_tr)
predict_ts = classif.prediction(x_ts)
# Métriques pour évaluer l'entraînement et test
prs_tr, rec_tr, fbeta_tr, _ = metriques(t_tr, predict_tr, average='macro')
prs_ts, rec_ts, fbeta_ts, _ = metriques(t_ts, predict_ts, average='macro')
acc_tr = accu(t_tr, predict_tr)
acc_ts = accu(t_ts, predict_ts)
tab_perform = [['Accuracy', acc_tr, acc_ts],['Précision', prs_tr, prs_ts],\
['Rappel', rec_tr, rec_ts],['F-Beta', fbeta_tr, fbeta_ts]]
print(
tabulate(tab_perform,
headers=['Metrique', 'Train', 'Test'],
floatfmt='.4f'))
return tab_perform
def test_entrainement():
reg = Regression(lamb=0, m=0)
w = [0.3, 4.1]
modele_gen = "tanh"
nb_train = 1000
nb_test = 100
bruit = 0.2
gestionnaire_donnees = gd.GestionDonnees(w, modele_gen, nb_train,
nb_test, bruit)
[x_train, t_train, x_test,
t_test] = gestionnaire_donnees.generer_donnees()
print("x", x_train.shape)
phi_x = reg.entrainement(x_train, t_train, using_sklearn=True)
t_pred_train = phi_x.dot(reg.w)
print(t_pred_train.shape)
phi_x_test = reg.fonction_base_polynomiale(x_test)
t_pred_test = phi_x_test.dot(reg.w)
plt.subplot(211)
plt.title('Donnees d\'entrainement')
plt.scatter(x_train, t_train)
plt.scatter(x_train, t_pred_train)
plt.subplot(212)
plt.title('Donnees de test')
plt.scatter(x_test, t_test)
plt.scatter(x_test, t_pred_test)
plt.show()
def main():
if len(sys.argv) < 8:
print("Usage: python regression.py sk modele_gen nb_train nb_test bruit M lambda\n")
print("\t sk=0: using_sklearn=False, sk=1: using_sklearn=True")
print("\t modele_gen=lineaire, sin ou tanh")
print("\t nb_train: nombre de donnees d'entrainement")
print("\t nb_test: nombre de donnees de test")
print("\t bruit: amplitude du bruit appliqué aux données")
print("\t M: degré du polynome de la fonction de base (recherche d'hyperparametre lorsque M<0) ")
print("\t lambda: lambda utilisé par le modele de Ridge\n")
print(" exemple: python3 regression.py 1 sin 20 20 0.3 10 0.001\n")
return
skl = int(sys.argv[1]) > 0.5
modele_gen = sys.argv[2]
nb_train = int(sys.argv[3])
nb_test = int(sys.argv[4])
bruit = float(sys.argv[5])
m = int(sys.argv[6])
lamb = float(sys.argv[7])
w = [0.3, 4.1] # Parametres du modele generatif
# Creer le gestionnaire de donnees et generer les donnees d'entraînement et de test
gestionnaire_donnees = gd.GestionDonnees(w, modele_gen, nb_train, nb_test, bruit)
[x_train, t_train, x_test, t_test] = gestionnaire_donnees.generer_donnees()
# Entrainement du modele de regression
regression = sr.Regression(lamb, m)
regression.entrainement(x_train, t_train, using_sklearn=skl)
# Predictions sur les ensembles d'entrainement et de test
predictions_train = np.array([regression.prediction(x, skl) for x in x_train])
predictions_test = np.array([regression.prediction(x, skl) for x in x_test])
# Calcul des erreurs
erreurs_entrainement = np.array([regression.erreur(t_n, p_n)
for t_n, p_n in zip(t_train, predictions_train)])
erreurs_test = np.array([regression.erreur(t_n, p_n)
for t_n, p_n in zip(t_test, predictions_test)])
print("Erreur d'entraînement :", "%.2f" % erreurs_entrainement.mean())
print("Erreur de test :", "%.2f" % erreurs_test.mean())
print("")
warning(erreurs_test.mean(), erreurs_entrainement.mean(), bruit)
# Affichage
gestionnaire_donnees.afficher_donnees_et_modele(x_train, t_train, True)
predictions_range = np.array([regression.prediction(x, using_sklearn=skl) for x in np.arange(0, 1, 0.01)])
gestionnaire_donnees.afficher_donnees_et_modele(np.arange(0, 1, 0.01), predictions_range, False)
if m >= 0:
plt.suptitle('Resultat SANS recherche d\'hyperparametres')
else:
plt.suptitle('Resultat AVEC recherche d\'hyperparametres')
plt.show()
def test_fonction_recherche_hyperparametres():
reg = Regression(lamb=5, m=5)
w = [0.3, 4.1] # Parametres du modele generatif
modele_gen = "lineaire"
nb_train = 499
nb_test = 20
bruit = 0.1
gestionnaire_donnees = gd.GestionDonnees(w, modele_gen, nb_train,
nb_test, bruit)
[x_train, t_train, x_test,
t_test] = gestionnaire_donnees.generer_donnees()
M = reg.recherche_hyperparametre(t_train, x_train, 2, 10)
def main():
pca = decomposition.PCA()
svm = SVM()
#Récupération des donnees
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train,
labels] = donnees.recupDonnees() #stockage données csv dans variables
#Selection du classifieurs svm avec les meilleurs parametres
clf = svm.hyperParameter(X_train, y_train)
#Validation
svm.validationCroisee(train, labels)
def main():
if len(sys.argv) < 6:
usage = "\n Usage: python non_lineaire_classification.py type_noyau nb_train nb_test lin validation\
\n\n\t type_noyau: rbf, lineaire, polynomial, sigmoidal\
\n\t nb_train, nb_test: nb de donnees d'entrainement et de test\
\n\t lin : 0: donnees non lineairement separables, 1: donnees lineairement separable\
\n\t validation: 0: pas de validation croisee, 1: validation croisee\n"
print(usage)
return
type_noyau = sys.argv[1]
nb_train = int(sys.argv[2])
nb_test = int(sys.argv[3])
lin_sep = int(sys.argv[4])
vc = bool(int(sys.argv[5]))
# On génère les données d'entraînement et de test
generateur_donnees = gd.GestionDonnees(nb_train, nb_test, lin_sep)
[x_train, t_train, x_test, t_test] = generateur_donnees.generer_donnees()
# On entraine le modèle
mp = MAPnoyau(noyau=type_noyau)
if vc is False:
mp.entrainement(x_train, t_train)
else:
# mp.entrainement(x_train, t_train)
mp.validation_croisee(x_train, t_train)
# ~= À MODIFIER =~.
# AJOUTER CODE AFIN DE CALCULER L'ERREUR D'APPRENTISSAGE
# ET DE VALIDATION EN % DU NOMBRE DE POINTS MAL CLASSES
err_train = mp.erreur(t_train,
np.array([mp.prediction(x) for x in x_train]))
err_test = mp.erreur(t_test, np.array([mp.prediction(x) for x in x_test]))
err_train = 100 * np.sum(err_train) / len(t_train)
err_test = 100 * np.sum(err_test) / len(t_test)
print('Erreur train = ', err_train, '%')
print('Erreur test = ', err_test, '%')
analyse_erreur(err_train, err_test)
# Affichage
mp.affichage(x_train, t_train)
mp.affichage(x_test, t_test)
def main():
#Création objet
perceptron = Perceptr()
#Récupération des donnees
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train,
labels] = donnees.recupDonnees()
#recherche des hyperparametres
classifieur = perceptron.rechercheHypParm(X_train, y_train, X_test, y_test)
#validation avec les HP trouvés précédemment
perceptron.cross_validation(train, labels, classifieur)
#test
print("\n\nVoici les cibles prédites sur nos 594 données de test")
print(perceptron.predict_all(test))
def main():
#Creation de l'objet
nb = NaiveBayes()
#Récupération des données
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train, labels] = donnees.recupDonnees()
# X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25)
classifieur = nb.choixNB(X_train, y_train,
X_test, y_test)
nb.validation_croisee(train, labels,
classifieur, 10)
def main():
if len(sys.argv) < 6:
usage = "\n Usage: python non_lineaire_classification.py type_noyau nb_train nb_test lin validation\
\n\n\t type_noyau: rbf, lineaire, polynomial, sigmoidal\
\n\t nb_train, nb_test: nb de donnees d'entrainement et de test\
\n\t lin : 0: donnees non lineairement separables, 1: donnees lineairement separable\
\n\t validation: 0: pas de validation croisee, 1: validation croisee\n"
print(usage)
return
type_noyau = sys.argv[1]
nb_train = int(sys.argv[2])
nb_test = int(sys.argv[3])
lin_sep = int(sys.argv[4])
vc = bool(int(sys.argv[5]))
# On génère les données d'entraînement et de test
generateur_donnees = gd.GestionDonnees(nb_train, nb_test, lin_sep)
[x_train, t_train, x_test, t_test] = generateur_donnees.generer_donnees()
# On entraine le modèle
mp = MAPnoyau(noyau=type_noyau)
if vc is False:
mp.entrainement(x_train, t_train)
else:
mp.validation_croisee(x_train, t_train)
err_x_train = [
mp.erreur(t_train[i], mp.prediction(x_train[i]))
for i in range(x_train.shape[0])
]
err_x_test = [
mp.erreur(t_test[i], mp.prediction(x_test[i]))
for i in range(x_test.shape[0])
]
err_train = 100 * np.sum(err_x_train) / x_train.shape[0]
err_test = 100 * np.sum(err_x_test) / x_test.shape[0]
print('Erreur train = ', err_train, '%')
print('Erreur test = ', err_test, '%')
analyse_erreur(err_train, err_test)
# Affichage
mp.affichage(x_test, t_test)
def main():
if len(sys.argv) < 7:
usage = "\n Usage: python classifieur.py method nb_train nb_test lambda bruit corruption don_ab\
\n\n\t method : 1 => Classification generative\
\n\t method : 2 => Perceptron + SDG \n\t method : 3 => Perceptron + SDG [sklearn]\
\n\t nb_train, nb_test : nombre de donnees d'entrainement et de test\
\n\t lambda >=0\
\n\t bruit : multiplicateur de la matrice de variance-covariance (entre 0.1 et 50)\
\n\t don_ab : production ou non de données aberrantes (0 ou 1) \
\n\n\t ex : python classifieur_lineaire.py 1 280 280 0.001 1 1"
print(usage)
return
method = int(sys.argv[1])
nb_train = int(sys.argv[2])
nb_test = int(sys.argv[3])
lamb = float(sys.argv[4])
bruit = float(sys.argv[5])
donnees_aberrantes = bool(int(sys.argv[6]))
print("Generation des données d'entrainement...")
gestionnaire_donnees = gd.GestionDonnees(donnees_aberrantes, nb_train,
nb_test, bruit)
[x_train, t_train, x_test,
t_test] = gestionnaire_donnees.generer_donnees() #t_train/test = 1 ou 0
classifieur = solution.ClassifieurLineaire(lamb, method)
# Entraînement de la classification linéaire
classifieur.entrainement(x_train, t_train)
# Prédictions sur les ensembles d'entraînement et de test
predictions_entrainement = np.array(
[classifieur.prediction(x) for x in x_train]) #279
print(
"Erreur d'entrainement = ", 100 *
np.sum(np.abs(predictions_entrainement - t_train)) / len(t_train), "%")
predictions_test = np.array([classifieur.prediction(x) for x in x_test])
print("Erreur de test = ",
100 * np.sum(np.abs(predictions_test - t_test)) / len(t_test), "%")
# Affichage
classifieur.afficher_donnees_et_modele(x_train, t_train, x_test, t_test)
def main():
if len(sys.argv) < 6:
usage = "\n Usage: python non_lineaire_classification.py type_noyau nb_train nb_test lin validation\
\n\n\t type_noyau: rbf, lineaire, polynomial, sigmoidal\
\n\t nb_train, nb_test: nb de donnees d'entrainement et de test\
\n\t lin : 0: donnees non lineairement separables, 1: donnees lineairement separable\
\n\t validation: 0: pas de validation croisee, 1: validation croisee\n"
print(usage)
return
type_noyau = sys.argv[1]
nb_train = int(sys.argv[2])
nb_test = int(sys.argv[3])
lin_sep = int(sys.argv[4])
vc = bool(int(sys.argv[5]))
# On génère les données d'entraînement et de test
generateur_donnees = gd.GestionDonnees(nb_train, nb_test, lin_sep)
[x_train, t_train, x_test, t_test] = generateur_donnees.generer_donnees()
# On entraine le modèle
mp = MAPnoyau(noyau=type_noyau)
if vc is False:
mp.entrainement(x_train, t_train)
else:
mp.validation_croisee(x_train, t_train)
err_train = np.average(
[mp.erreur(t, mp.prediction(x))
for x, t in zip(x_train, t_train)]) * 100
err_test = np.average(
[mp.erreur(t, mp.prediction(x)) for x, t in zip(x_test, t_test)]) * 100
print("Erreur train = {:.03} %".format(err_train))
print("Erreur test = {:.03} %".format(err_test))
analyse_erreur(err_train, err_test)
# Affichage
mp.affichage(x_test, t_test)
def main():
#Création de l'objet
combinaison_modeles = Combinaison()
#Récupération des donnees
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train,
labels] = donnees.recupDonnees() #stockage données csv dans variables
#Récupération des meilleurs classifieurs pour chaque méthode
combinaison_modeles.clfNB, combinaison_modeles.clfTree, combinaison_modeles.kNN, combinaison_modeles.clfPerceptr, combinaison_modeles.clfSVM = combinaison_modeles.choix_classifieurs(
X_train, y_train, X_test, y_test)
#Prédiction
pred_test = combinaison_modeles.predictionsTest(X_train, y_train, X_test,
y_test, test, train,
labels)
pred_validation = combinaison_modeles.predictionsValidation(
X_train, y_train, X_test, y_test)
def main():
#Récupération des donnees
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train, labels] = donnees.recupDonnees()#stockage données csv dans variables
#Création d'un objet
tree = DecisionTree()
#Recherche du meilleur classifieur
clf,afficher = tree.recherche_param(X_train,
y_train, X_test,
y_test)
#Affichage des test pour les paramètresp
tree.affichageParam(afficher)
#Valisation croisee
tree.validation_croisee(train, labels, clf)
#Prédiction du des donnees de test
clf.fit(X_train,y_train)
pred = tree.prediction(test, clf)
print("Prédictions faites sur les données de test : ",pred)
def main():
#Récupération des parametres
if len(sys.argv) < 2:
usage = "\n k nombre de voisins pour la prédiction\
\n\t lin : 0: prédiction avec données de validation, 1: prédiction avec données de test"
print(usage)
return
k = sys.argv[1]
choixTest = int(sys.argv[2])
#Creation de l'objet
knn = KNN()
#Récupération des donnees
donnees = gd.GestionDonnees()
[X_train, y_train, X_test, y_test, test, train,
labels] = donnees.recupDonnees() #stockage données csv dans variables
#Taille des échantillons
knn.nb_train = len(X_train)
knn.nb_test = len(X_test)
knn.test = len(test)
#Validation croisee
#knn.validation_croisee(train, labels)
#Prédiction pour tous les k
#knn.prediction_all_k(X_train, y_train, X_test, y_test)
#Donnees de test, sans cible
if (choixTest == 1):
print("-- Prédicitions des données de test avec affichage --")
knn.affichage(X_train, y_train, test, k)
#Donnees de validation
else:
print(
"\n-- Prédicitions des données de validation avec affichage --\n")
knn.affichage(X_train, y_train, X_test, k, y_test)
def main():
if len(sys.argv) < 4:
print(
"Usage: python visualisation3D.py modele_gen nb_train bruit lambda\n"
)
print("\t modele_gen=lineaire, sin ou tanh")
print("\t nb_train: nombre de donnees d'entrainement")
print("\t bruit: amplitude du bruit appliqué aux données")
print("\t lambda: lambda utilisé par le modele de Ridge\n")
print(" exemple: python3 visualisation3D.py sin 200 0.3 0.001\n")
return
w = [0.3, 4.1] # Parametres du modele generatif
modele_gen = sys.argv[1]
nb_train = int(sys.argv[2])
nb_test = 0
bruit = float(sys.argv[3])
# Parametre de la regression:
lamb = float(sys.argv[4])
m = 3
skl = False
# Modèle génératif:
gestionnaire_donnees = gd.GestionDonnees(w, modele_gen, nb_train, nb_test,
bruit)
[x_train, t_train, _, _] = gestionnaire_donnees.generer_donnees()
# On trouve les paramètres de regression du modèle:
regression = sr.Regression(lamb, m)
regression.entrainement(x_train, t_train, using_sklearn=skl)
print("Modèle déterminé: ", regression.w)
# phi_x est un vecteur de taille nbre_donnees x m
# m=3 donc on crée des vecteurs de R^3
phi_x = regression.fonction_base_polynomiale(x_train, using_sklearn=skl)
# On prédit avec notre modèle un vecteur de cible sur notre jeu d'apprentissage
t_pred = phi_x.dot(regression.w)
# On trace nos résultats:
fig = plt.figure()
ax = plt.axes(projection='3d')
# Données dans R^3:
ax.scatter3D(phi_x[:, 1], phi_x[:, 2], t_train, c='red')
# Notre modèle:
x = np.expand_dims(np.arange(0, 1, 0.1), axis=1)
y = x**2
X, Y = np.meshgrid(x, y)
ones = np.ones((10, 10))
Z = regression.w[0] * ones + regression.w[1] * X + regression.w[2] * Y
ax.set_title('Projection dans un espace à 3 dimensions')
ax.set_xlabel('X')
ax.set_ylabel('X^2')
ax.set_zlabel('Prédiction (combinaison linéaire de X et X^2)')
# On trace notre plan:
ax.plot_surface(X, Y, Z, linewidth=0, cmap='viridis', antialiased=False)
# On regarde l'efficacité du modèle sur nos données à 1 dimension:
fig2 = plt.figure()
ax2 = plt.axes()
ax.set_xlabel('X')
ax.set_ylabel('Cible')
ax2.scatter(phi_x[:, 1], t_train, label="Cible")
ax2.scatter(phi_x[:, 1], t_pred, label="Prediction")
ax2.legend()
plt.show(block=True)
def main():
if(len(sys.argv) != 4):
usage = "\n Usage: python Projet.py choix_algorithme recherche_parametres generer_soumission\
\n\n\t choix_algorithme:\
\n\t\t -1 : Tous les algorithmes\
\n\t\t 0 : Gradient Boosting Classifier\
\n\t\t 1 : Random-Forest\
\n\t\t 2 : ADA-Boost\
\n\t\t 3 : Decision-Tree\
\n\t\t 4 : SVM\
\n\t\t 5 : K-nearest neighbors\
\n\t\t 6 : Linear Discriminant Analysis\
\n\t\t 7 : Quadratic Discriminant Analysis\
\n\t recherche_parametres :\
\n\t\t 0 : Pas de recherche de parametres\
\n\t\t 1 : Recherche des meilleurs parametres\
\n\t generer_soumission :\
\n\t\t 0 : Pas de prédiction sur les données du fichier test.csv\
\n\t\t 1 : Prédiction sur les données du fichier test.csv\n"
print(usage)
return
choix_algorithme = int(sys.argv[1])
recherche_parametres = int(sys.argv[2])
generer_soumission = int(sys.argv[3])
# On génère les données d'entraînement et de test
generateur_donnees = gd.GestionDonnees()
start = time.time()
[x_entrainement,t_entrainement,x_test] = generateur_donnees.generer_donnees()
print("------- Fin du tri des donnees en ", time.time()-start, 'seconds')
# Nous allons étudier 8 algorithmes différents
liste_variables=[[[0] for j in range(len(x_entrainement))] for j in range(7)]
liste_variables_test=[[[0] for j in range(len(x_test))] for j in range(7)]
test_id=[[0] for j in range(len(x_test))]
# Liste des hyperparametres à tester pour chaque fonction
liste_parametres_atester=[ [[1,10,100],[1,0.1,0.01]] , [[100,537,1000],[None,10]] , [[100,1000],[1,0.1,0.01]] , [[6,20,100],[None,10,100]] , [[0.5,1,1.5,10,50,100,200,500,1000,5000,10000],["linear", "poly", "rbf", "sigmoid"]] , [[1,5,8,10],["ball_tree", "kd_tree", "brute"]] , [["svd","lsqr"],[1,0.1,0.01,0.001,0.0001]] , [[100,1000,10000],[1,10,100]] ]
# Liste des meilleurs hyperparametres de chaque fonction
liste_meilleurs_parametres=[ [100,0.01] , [1000,None] , [1000,0.01] , [6,None] , [200,"linear"] , [1,"ball_tree"] , ["svd",0.1] , [10000,100] ]
meilleurs_parametres=[[],[],[],[],[],[],[],[]]
meilleur_resultat=[[0] for j in range(len(liste_parametres_atester))]
meilleur_resultat_variables=[[0] for j in range(len(liste_parametres_atester))]
# Labels
liste_variables_label=["Utilisation de Margin seulement","Utilisation de Shape seulement","Utilisation de Texture seulement","Utilisation de Margin et Shape","Utilisation de Margin et Texture","Utilisation de Shape et Texture","Utilisation de toutes les variables"]
liste_variables_fichier=["Margin","Shape","Texture","Margin_Shape","Margin_Texture","Shape_Texture","Tout"]
list_Algorithme_label=["~~~~~~~~~~~~~ GradientBoostingClassifier ~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~ Random-Forest ~~~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~~~ ADA-Boost ~~~~~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~~ Decision-Tree ~~~~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~ SVM ~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~~ K-nearest neighbors ~~~~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~ Linear Discriminant Analysis ~~~~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~ Bagging Classifier ~~~~~~~~~~~~~~~~~~"]
Test_resultat=["GradientBoostingClassifier","Random-Forest","ADA-Boost","Decision-Tree","SVM","K-nearestneighbors","Linear_Discriminant_Analysis","BaggingClassifier"]
for i in range(len(x_entrainement)):
liste_variables[0][i]=x_entrainement[i][0:64] # Seulement Margin
liste_variables[1][i]=x_entrainement[i][64:128] # Seulement Shape
liste_variables[2][i]=x_entrainement[i][128:] # Seulement Texture
liste_variables[3][i]=x_entrainement[i][0:128] # Seulement Margin and Shape
liste_variables[4][i]=np.concatenate((x_entrainement[i][0:64], x_entrainement[i][128:]), axis=0) # Seulement Margin and Texture
liste_variables[5][i]=x_entrainement[i][64:] # Seulement Shape and Texture
liste_variables[6][i]=x_entrainement[i] # Tous les parametres
for i in range(len(x_test)):
test_id[i] = x_test[i][0]
liste_variables_test[0][i]=x_test[i][1:65] # Seulement Margin
liste_variables_test[1][i]=x_test[i][65:129] # Seulement Shape
liste_variables_test[2][i]=x_test[i][129:] # Seulement Texture
liste_variables_test[3][i]=x_test[i][1:129] # Seulement Margin and Shape
liste_variables_test[4][i]=np.concatenate((x_test[i][1:65], x_test[i][129:]), axis=0) # Seulement Margin and Texture
liste_variables_test[5][i]=x_test[i][65:] # Seulement Shape and Texture
liste_variables_test[6][i]=x_test[i][1:] # Tous les parametres
# Si on sélectionne tous les algorithmes
if(choix_algorithme==-1):
for algorithme_choisi in range(len(list_Algorithme_label)):
print("\n",list_Algorithme_label[algorithme_choisi])
# Recherche des meilleurs parametres de l'algorithme
if(recherche_parametres==1): # On recherche les meilleurs hyperparametres
print("\n Avec recherche d'hypermarametres")
meilleurs_parametres[algorithme_choisi] = Recherche_meilleurs_parametres(liste_variables[6], t_entrainement, liste_parametres_atester[algorithme_choisi], algorithme_choisi)
print("Les meilleurs parametres calculés sont : ", meilleurs_parametres[algorithme_choisi][0], " et ", meilleurs_parametres[algorithme_choisi][1],"\n")
# Pas de recherche des meilleurs parametres de l'algorithme
else: # On prend les meilleurs parametres
print("\n Sans recherche d'hypermarametres")
meilleurs_parametres[algorithme_choisi] = [liste_meilleurs_parametres[algorithme_choisi][0],liste_meilleurs_parametres[algorithme_choisi][1]]
print("Les meilleurs parametres préalablement calculés sont : ", meilleurs_parametres[algorithme_choisi][0], " et ", meilleurs_parametres[algorithme_choisi][1],"\n")
meilleur_resultat[algorithme_choisi]=0
meilleur_resultat_variables[algorithme_choisi]=""
for variable_choisie in range(len(liste_variables)):
precision = Run_algorithme(liste_variables_label[variable_choisie],liste_variables[variable_choisie],t_entrainement,liste_variables_test[variable_choisie],meilleurs_parametres[algorithme_choisi],algorithme_choisi,Test_resultat[algorithme_choisi],generer_soumission,liste_variables_fichier[variable_choisie],test_id)
if(precision > meilleur_resultat[algorithme_choisi]):
meilleur_resultat[algorithme_choisi] = precision
meilleur_resultat_variables[algorithme_choisi]=liste_variables_label[algorithme_choisi]
# Visualisation graphique des meilleurs résultats de chaque algorithme
print("\n")
for resultat in range(len(meilleur_resultat)):
print(Test_resultat[resultat], " : ",meilleur_resultat[resultat])
print("\n")
plt.figure(0)
plt.bar(Test_resultat, meilleur_resultat)
plt.show()
# Si on sélectionne un algorithme
else: # Pour un algorithme
print("\n",list_Algorithme_label[choix_algorithme])
# Recherche des meilleurs parametres de l'algorithme
if(recherche_parametres==1):
print("\n Avec recherche d'hypermarametres")
meilleurs_parametres[choix_algorithme] = Recherche_meilleurs_parametres(liste_variables[6], t_entrainement, liste_parametres_atester[choix_algorithme], choix_algorithme)
print("Les meilleurs parametres calculés sont : ", meilleurs_parametres[choix_algorithme][0], " et ", meilleurs_parametres[choix_algorithme][1],"\n")
# Pas de recherche des meilleurs parametres de l'algorithme
else:
print("\n Sans recherche d'hypermarametres")
meilleurs_parametres[choix_algorithme] = [liste_meilleurs_parametres[choix_algorithme][0],liste_meilleurs_parametres[choix_algorithme][1]]
print("Les meilleurs parametres préalablement calculés sont : ", meilleurs_parametres[choix_algorithme][0], " et ", meilleurs_parametres[choix_algorithme][1],"\n")
for variable_choisie in range(len(liste_variables)):
Run_algorithme(liste_variables_label[variable_choisie],liste_variables[variable_choisie],t_entrainement,liste_variables_test[variable_choisie],meilleurs_parametres[choix_algorithme],choix_algorithme,Test_resultat[choix_algorithme],generer_soumission,liste_variables_fichier[variable_choisie],test_id)
