📝 dooc

analise.py

@@ -4,19 +4,21 @@ from sklearn.model_selection import learning_curve
 import numpy as np
 from sklearn import metrics
 
-
+# Fonction pour calculer la matrice de confusion, le rapport de classification et l'exactitude
 def calculateMatrix(y_true, y_pred):
     accuracy = accuracy_score(y_true, y_pred)
     confusion_matrix_result = confusion_matrix(y_true, y_pred)
     classification_report_result = classification_report(y_true, y_pred, zero_division=1)
     return accuracy, confusion_matrix_result, classification_report_result
 
+# Fonction pour afficher une matrice de confusion
 def seeMatrix(matrix, classes):
     cmap = plt.cm.Blues
     disp = ConfusionMatrixDisplay(confusion_matrix=matrix, display_labels=classes)
     disp.plot(cmap=cmap)
     plt.show()
 
+# Fonction pour tracer la courbe ROC
 def rocCurve(y_test, y_pred):
     fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred)
     roc_auc = metrics.auc(fpr, tpr)
@@ -24,9 +26,11 @@ def rocCurve(y_test, y_pred):
                                     estimator_name='example estimator')
     display.plot()
 
+# Fonction pour visualiser la courbe d'apprentissage
 def seeRocCurve(model, X_train, y_train, learning_reps):
+    # Calcul des scores d'apprentissage et de test en fonction de la taille de l'ensemble d'apprentissage
     train_sizes, train_scores, test_scores = learning_curve(model, X_train, y_train, cv=learning_reps, scoring='accuracy', n_jobs=-1)
-
+    # Calcul des moyennes des scores d'apprentissage et de test
     train_scores_mean = np.mean(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
 

cleanData.py

@@ -10,6 +10,7 @@ from models import *
 import random
 from analise import *
 
+# Défini toutes les colonnes à garder dans le nettoyage des données
 columns = ['B_fighter','R_fighter','title_bout',
                     'B_avg_BODY_landed', 'B_avg_HEAD_landed', 'B_avg_TD_att', 'B_avg_TOTAL_STR_landed', 
                 'B_avg_opp_BODY_att', 'B_avg_opp_HEAD_landed', 'B_avg_opp_LEG_landed', 
@@ -22,12 +23,15 @@ columns = ['B_fighter','R_fighter','title_bout',
                 'B_age', 'R_age','date','Winner','weight_class','B_Stance','R_Stance'] 
 
 def swap_values(row):
+    # Choisi avec 1 chance sur 2 si le swap va être effectué
     if random.random() > 0.5:
         for column in columns:
             if column.startswith('B_'):
+                # Si la colonne commence par B_, on l'échange par R_
                 opposite_column = 'R_' + column[2:]
                 row[column], row[opposite_column] = row[opposite_column], row[column]
             if column.startswith('Winner'):
+                # Si la valeur de Winner est 0, on remplace par 2 et vice-versa
                 print(row[column])
                 if row[column] == 0:
                     row[column] = 2
@@ -35,27 +39,33 @@ def swap_values(row):
                     row[column] = 0
                 print(row[column])
         return row
+    # retourne ligne inchangée si swap non effectué
     return row
 
 def getData():
     df = pd.read_csv('archive/data.csv')
 
+    # Défini la date limite pour utiliser les données
     limit_date = '2001-04-01'
     df = df.loc[df['date'] > limit_date, columns]
 
     label_encoder = LabelEncoder()
     # Convertir les chaînes de caractères en nombres
     for column in df.select_dtypes(include=['object']).columns:
+        # Encode pour chaque colonne de type chaînes de caractères en valeur numérique
         df[column] = label_encoder.fit_transform(df[column])
 
     df = df.apply(swap_values, axis=1)
 
+    # Remplace toutes les valeurs NaN par la valeur médiane associée
     median_values = df.median()
     df.fillna(median_values, inplace=True)
 
     imp_features = ['R_age', 'B_age']
 
+    # On crée un dataframe sans colonne winner car c'est ce qu'on cherche à prédire
     X=df.drop('Winner', axis=1)
+    # On crée un dataframe avec seulement la colonne winner pour vérifier les prédictions
     y=df['Winner']
     return X,y
 

models.py

@@ -9,23 +9,31 @@ from sklearn.naive_bayes import GaussianNB
 
 
 def RandomForest(X_train, X_test, y_train):
-    random_forest = RandomForestClassifier(n_estimators=100, 
-                                       criterion='entropy', 
-                                       max_depth=10, 
-                                       min_samples_split=2,
-                                       min_samples_leaf=1, 
-                                       random_state=0)                              
+    random_forest = RandomForestClassifier(
+            n_estimators=100,  # Nombre d'arbres dans la forêt
+            criterion='entropy',  # Critère pour diviser les nœuds 
+            max_depth=10,  # Profondeur maximale des arbres
+            min_samples_split=2,  # Nombre minimal d'échantillons requis pour diviser un nœud
+            min_samples_leaf=1,  # Nombre minimal d'échantillons requis pour être une feuille
+            random_state=0  # Contrôle la randomisation
+    )
+    # Entraînement du classificateur sur les données d'entraînement                             
     random_forest.fit(X_train, y_train)
+    # Prédiction sur les données de test
     return  random_forest.predict(X_test), random_forest
 
 def KNN(X_train, X_test, y_train):
-    knn = KNeighborsClassifier(n_neighbors=5)
+    knn = KNeighborsClassifier(
+        n_neighbors=5  # Nombre de voisins à utiliser
+    )
     knn.fit(X_train, y_train)
     return knn.predict(X_test),knn
 
 
 def SVM(X_train, X_test, y_train):
-    clf = svm.SVC(gamma=0.001)
+    clf = svm.SVC(
+        gamma=0.001  # Paramètre de noyau
+    )
     clf.fit(X_train,y_train)
     return clf.predict(X_test),clf
 
@@ -40,7 +48,13 @@ def LogisticRegress(X_train, X_test, y_train):
     return logistic.predict(X_test),logistic
 
 def Linearsvc(X_train, X_test, y_train):
-    svc = LinearSVC(C=1.0, dual=False, verbose=True, loss="squared_hinge", multi_class="crammer_singer")
+    svc = LinearSVC(
+        C=1.0,  # Paramètre de régularisation 
+        dual=False,  # Utilisation de la forme duale 
+        verbose=True,  # Affichage des détails de l'optimisation
+        loss="squared_hinge",  # Fonction de perte utilisée
+        multi_class="crammer_singer"  # Méthode pour résoudre les problèmes de classification multi-classes
+    )
     svc.fit(X_train,y_train)
     return svc.predict(X_test),svc