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)