✨ Comments and prediction

README.md

@@ -1,6 +1,6 @@
 # Introduction
 
-Voici MMIX, une application IA permettant de prédire à hauteur de 63% la probabilité de victore d'un combat entre deux combattants MMA. 
+Voici MMIX, une application IA permettant de prédire à hauteur de 57% la probabilité de victore d'un combat entre deux combattants MMA. 
 
 Les statistiques sont issu d'un dataframe disponible sur [Kaggle](https://www.kaggle.com/datasets/rajeevw/ufcdata).
 

analise.py

@@ -1,39 +0,0 @@
-from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, ConfusionMatrixDisplay, roc_curve, auc, RocCurveDisplay
-import matplotlib.pyplot as plt
-from sklearn.model_selection import learning_curve
-import numpy as np
-from sklearn import metrics
-
-
-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
-
-def seeMatrix(matrix, classes):
-    cmap = plt.cm.Blues
-    disp = ConfusionMatrixDisplay(confusion_matrix=matrix, display_labels=classes)
-    disp.plot(cmap=cmap)
-    plt.show()
-
-def rocCurve(y_test, y_pred):
-    fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred)
-    roc_auc = metrics.auc(fpr, tpr)
-    display = metrics.RocCurveDisplay(fpr=fpr, tpr=tpr, roc_auc=roc_auc,
-                                    estimator_name='example estimator')
-    display.plot()
-
-def seeRocCurve(model, X_train, y_train, learning_reps):
-    train_sizes, train_scores, test_scores = learning_curve(model, X_train, y_train, cv=learning_reps, scoring='accuracy', n_jobs=-1)
-
-    train_scores_mean = np.mean(train_scores, axis=1)
-    test_scores_mean = np.mean(test_scores, axis=1)
-
-    plt.plot(train_sizes, train_scores_mean, label='Entrainement')
-    plt.plot(train_sizes, test_scores_mean, label='Test')
-    plt.xlabel("lol")
-    plt.ylabel('Score')
-    plt.title('Courbe d apprentissage')
-    plt.legend()
-    plt.show()

analyse.py

@@ -0,0 +1,69 @@
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, ConfusionMatrixDisplay, roc_curve, auc, RocCurveDisplay
+import matplotlib.pyplot as plt
+from sklearn.model_selection import learning_curve
+import numpy as np
+from sklearn import metrics
+from sklearn.preprocessing import LabelEncoder
+from cleanData import *
+import sys
+
+# Fonction permettant de récupérer la moyenne de statistiques des combats précédents
+def getFighterStats(df, label_encoder, fighter_name):
+    # Définition des colonnes ou la moyenne sera appliquée
+    columns = ['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', 
+                'B_avg_opp_SIG_STR_att', 'B_avg_opp_TOTAL_STR_att'] 
+    # Tentative de récupération du dataframe ou le fighter passée en paramètre combat
+    df_temp = df[(df['R_fighter'] == fighter_name) | (df['B_fighter'] == fighter_name)]
+    # Gestion d'erreur si le df est vide
+    if df_temp.empty:
+        print(f"{fighter_name} introuvable. Abandon de l'application")
+        sys.exit(1)
+    # sous-fonction permettant d'inverser le coté du combattant
+    def swap_values_if_needed(row):
+        if row['R_fighter'] == fighter_name:
+            return swap_values_withoutran(row)
+        return row
+    # Permet de faire un foreach et d'appliquer la fonction swap_values_if_needed pour chaque ligne
+    df_temp = df_temp.apply(swap_values_if_needed, axis=1)
+    # Fait la moyenne des colonnes précédement renseignée dans la liste columns
+    return df_temp[columns].mean()
+
+def predict(fighterStatsR,fighterStatsB,titlebout,model,weight):
+    # Définition des colonnes attendus pour la prédiction
+    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', 
+                'B_avg_opp_SIG_STR_att', 'B_avg_opp_TOTAL_STR_att',
+                
+                'R_avg_BODY_landed', 'R_avg_HEAD_landed', 'R_avg_TD_att', 'R_avg_TOTAL_STR_landed', 
+                'R_avg_opp_BODY_att', 'R_avg_opp_HEAD_landed', 'R_avg_opp_LEG_landed', 
+                'R_avg_opp_SIG_STR_att', 'R_avg_opp_TOTAL_STR_att','weight_class'] 
+
+    # Définition d'un dataframe issu des colonnes précedemment renseignée
+    df = pd.DataFrame(columns=columns)
+    # Association des valeurs liées au deux combattants pour la prédiction
+    fight = {'B_fighter':0,'R_fighter':0,'title_bout':1,'B_avg_BODY_landed': fighterStatsB['B_avg_BODY_landed'],
+        'B_avg_HEAD_landed': fighterStatsB['B_avg_HEAD_landed'], 'B_avg_TD_att': fighterStatsB['B_avg_TD_att'],
+        'B_avg_TOTAL_STR_landed': fighterStatsB['B_avg_TOTAL_STR_landed'],
+        'B_avg_opp_BODY_att': fighterStatsB['B_avg_opp_BODY_att'],
+        'B_avg_opp_HEAD_landed': fighterStatsB['B_avg_opp_HEAD_landed'],
+        'B_avg_opp_LEG_landed': fighterStatsB['B_avg_opp_LEG_landed'],
+        'B_avg_opp_SIG_STR_att': fighterStatsB['B_avg_opp_SIG_STR_att'],
+        'B_avg_opp_TOTAL_STR_att': fighterStatsB['B_avg_opp_TOTAL_STR_att'],
+
+        'R_avg_BODY_landed': fighterStatsR['B_avg_BODY_landed'],
+        'R_avg_HEAD_landed': fighterStatsR['B_avg_HEAD_landed'], 'R_avg_TD_att': fighterStatsR['B_avg_TD_att'],
+        'R_avg_TOTAL_STR_landed': fighterStatsR['B_avg_TOTAL_STR_landed'],
+        'R_avg_opp_BODY_att': fighterStatsR['B_avg_opp_BODY_att'],
+        'R_avg_opp_HEAD_landed': fighterStatsR['B_avg_opp_HEAD_landed'],
+        'R_avg_opp_LEG_landed': fighterStatsR['B_avg_opp_LEG_landed'],
+        'R_avg_opp_SIG_STR_att': fighterStatsR['B_avg_opp_SIG_STR_att'],
+        'R_avg_opp_TOTAL_STR_att': fighterStatsR['B_avg_opp_TOTAL_STR_att'],
+
+        'weight_class': 1
+    }
+    # Ajout des valeurs dans le dataframe
+    df = df._append(fight, ignore_index=True)
+    # Retourne la valeur 'Winner' suite à la prédiction du model choisis
+    return model.predict(df)

cleanData.py

@@ -8,8 +8,9 @@ from sklearn.model_selection import train_test_split
 from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
 from models import *
 import random
-from analise import *
+from analyse import *
 
+# Définition des colonnes du dataframe à traiter
 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', 
@@ -17,45 +18,46 @@ columns = ['B_fighter','R_fighter','title_bout',
                 
                 'R_avg_BODY_landed', 'R_avg_HEAD_landed', 'R_avg_TD_att', 'R_avg_TOTAL_STR_landed', 
                 'R_avg_opp_BODY_att', 'R_avg_opp_HEAD_landed', 'R_avg_opp_LEG_landed', 
-                'R_avg_opp_SIG_STR_att', 'R_avg_opp_TOTAL_STR_att',
+                'R_avg_opp_SIG_STR_att', 'R_avg_opp_TOTAL_STR_att','Winner','weight_class'] 
-
-                'B_age', 'R_age','date','Winner','weight_class','B_Stance','R_Stance'] 
 
+# Permet d'inverser le coté des combattants
+# Permet ainsi de ne pas prendre en compte dans l'apprentissage le coté de départ (rouge ou bleu)
 def swap_values(row):
     if random.random() > 0.5:
-        for column in columns:
+        return swap_values_withoutran(row)
-            if column.startswith('B_'):
-                opposite_column = 'R_' + column[2:]
-                row[column], row[opposite_column] = row[opposite_column], row[column]
-            if column.startswith('Winner'):
-                print(row[column])
-                if row[column] == 0:
-                    row[column] = 2
-                elif row[column] == 2:
-                    row[column] = 0
-                print(row[column])
-        return row
     return row
 
-def getData():
+# Inverse le coté des combattants
-    df = pd.read_csv('archive/data.csv')
+def swap_values_withoutran(row):
-
+    for column in columns:
-    limit_date = '2001-04-01'
+        if column.startswith('B_'):
-    df = df.loc[df['date'] > limit_date, columns]
+            opposite_column = 'R_' + column[2:]
+            row[column], row[opposite_column] = row[opposite_column], row[column]
+        if column.startswith('Winner'):
+            if row[column] == 0:
+                row[column] = 2
+            elif row[column] == 2:
+                row[column] = 0
+    return row
 
-    label_encoder = LabelEncoder()
+# Récupere les données du fichier data.csv
-    # Convertir les chaînes de caractères en nombres
+def getData(label_encoder):
+    df = pd.read_csv('archive/data.csv')
+#Avant avril 2001, il n'y avait presque aucune règle dans l'UFC (pas de juges, pas de limites de temps, pas de rounds, 
+#etc.). C'est à partir de cette date précise que l'UFC a commencé à mettre en place un ensemble de règles connu sous 
+#le nom de "Unified Rules of Mixed Martial Arts". Par conséquent, nous supprimons tous les combats antérieurs 
+#à cette mise à jour majeure de l'histoire des règles de l'UFC.
+    df = df.loc[df['date'] > '2001-04-01', columns]
+# Copy le dataframe pour le traiter dans une autre fonction
+    dfc = df.copy()
+# Permet d'encoder la totalité des valeurs string en index (Int)
     for column in df.select_dtypes(include=['object']).columns:
         df[column] = label_encoder.fit_transform(df[column])        
-
+# Permet de générer l'aléatoire sur le coté de départ des combattants (bleu ou rouge)
     df = df.apply(swap_values, axis=1)
-
+# Drop de la colonne 'Winner' pour effectuer l'apprentissage
-    median_values = df.median()
-    df.fillna(median_values, inplace=True)
-
-    imp_features = ['R_age', 'B_age']
-
     X=df.drop('Winner', axis=1)
+# Mise en place du y, montrant la réponse aux prédictions attendus
     y=df['Winner']
-    return X,y
+    return X,y,dfc
 

main.py

@@ -1,17 +1,38 @@
-from runModel import *
+from startModel import *
 from cleanData import *
 from sklearn.model_selection import train_test_split
+from analyse import *
+import sys
+# Définition d'un label encoder pour changer les string en index
+label_encoder = LabelEncoder()
+# Récupération des valeurs X,y et d'un dataframe inchangé
+X, y, df = getData(label_encoder)
+# Séparation des différentes parties attendus pour faire le test et l'apprentissage du model sélectionnée
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=50)
 
-X,y=getData()
+model = startRandomForest(X_train, X_test, y_train, y_test)
-X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.30, random_state=50)
+#model=startKNN(X_train,X_test,y_train,y_test)
+#model=startSVM(X_train,X_test,y_train,y_test)
+#model=startDecisionTree(X_train,X_test,y_train,y_test)
+#model=startLogisticRegression(X_train,X_test,y_train,y_test)
+#model=startLinearSVC(X_train,X_test,y_train,y_test)
+#model=startNaiveBayes(X_train,X_test,y_train,y_test)
 
-startRandomForest(X_train,X_test,y_train,y_test)
+# Insertion des valeurs pour la prédiction
-#startKNN(X_train,X_test,y_train,y_test)
+combattantR = input("Combattant Rouge ?: ")
-#startSVM(X_train,X_test,y_train,y_test)
+combattantB = input("Combattant Bleu ?: ")
-#startDecisionTree(X_train,X_test,y_train,y_test)
+poids = input("Poids ?: ")
-#startLogisticRegression(X_train,X_test,y_train,y_test)
+belt = input("Ceinture ?: ")
 
-#startLinearSVC(X_train,X_test,y_train,y_test)
+# Récupération des valeurs indispensables pour la prédiction
-#startNaiveBayes(X_train,X_test,y_train,y_test)
+fr=getFighterStats(df, label_encoder, combattantR)
+fb=getFighterStats(df, label_encoder, combattantB)
 
-# https://scikit-learn.org/stable/_static/ml_map.png
+# Prédiction auprès du model sélectionnée
+winner = predict(fr, fb, belt, model, poids)
+
+# Affichage du gagnant prédit
+if winner == 0:
+    print(combattantR)
+else:
+    print(combattantB)

models.py

@@ -7,43 +7,48 @@ from sklearn import svm
 from sklearn.svm import LinearSVC
 from sklearn.naive_bayes import GaussianNB
 
-
+# Définition d'un model type RandomForest et entrainement sur les données passées en paramètre
 def RandomForest(X_train, X_test, y_train):
-    random_forest = RandomForestClassifier(n_estimators=100, 
+    random_forest = RandomForestClassifier(n_estimators=50, 
                                        criterion='entropy', 
-                                       max_depth=10, 
+                                       max_depth=20, 
                                        min_samples_split=2,
                                        min_samples_leaf=1, 
                                        random_state=0)                              
     random_forest.fit(X_train, y_train)
-    return  random_forest.predict(X_test), random_forest
+    return random_forest.predict(X_test), random_forest
 
+# Définition d'un model type KNN et entrainement sur les données passées en paramètre
 def KNN(X_train, X_test, y_train):
     knn = KNeighborsClassifier(n_neighbors=5)
     knn.fit(X_train, y_train)
     return knn.predict(X_test),knn
 
-
+# Définition d'un model type SVM et entrainement sur les données passées en paramètre
 def SVM(X_train, X_test, y_train):
     clf = svm.SVC(gamma=0.001)
     clf.fit(X_train,y_train)
     return clf.predict(X_test),clf
 
+# Définition d'un model type Arbre de décision et entrainement sur les données passées en paramètre
 def DecisionTree(X_train, X_test, y_train):
     decisionTree = DecisionTreeClassifier()
     decisionTree = decisionTree.fit(X_train,y_train)
     return decisionTree.predict(X_test),decisionTree
 
+# Définition d'un model type regression logistique et entrainement sur les données passées en paramètre
 def LogisticRegress(X_train, X_test, y_train):
     logistic = LogisticRegression()
     logistic.fit(X_train,y_train)
     return logistic.predict(X_test),logistic
 
+# Définition d'un model type SVC lineaire et entrainement sur les données passées en paramètre
 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.fit(X_train,y_train)
     return svc.predict(X_test),svc
 
+# Définition d'un model type Gaussian Naive Bayes et entrainement sur les données passées en paramètre
 def GaussianNaiveBayes(X_train, X_test, y_train):
     gnb = GaussianNB()
     gnb.fit(X_train, y_train)

runModel.py

@@ -1,64 +0,0 @@
-from models import *
-from analise import *
-
-def report(accuracy,confMatrix,classReport):
-    print(f'Accuracy: {accuracy}')
-    print(f'Confusion Matrix:\n{confMatrix}')
-    print(f'Classification Report:\n{classReport}')
-
-
-def startRandomForest(X_train,X_test,y_train,y_test):
-    y_pred, rf = RandomForest(X_train, X_test, y_train)
-    rf_ac, rf_matrix, rf_class_report = calculateMatrix(y_test, y_pred)
-    report(rf_ac, rf_matrix, rf_class_report)
-    seeMatrix(rf_matrix, rf.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startKNN(X_train,X_test,y_train,y_test):
-    y_pred, knn = KNN(X_train, X_test, y_train)
-    knn_ac, knn_matrix, knn_class_report = calculateMatrix(y_test, y_pred)
-    report(knn_ac, knn_matrix, knn_class_report)
-    seeMatrix(knn_matrix, knn.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startSVM(X_train,X_test,y_train,y_test):
-    y_pred, svm = SVM(X_train, X_test, y_train)
-    svm_ac, svm_matrix, svm_class_report = calculateMatrix(y_test, y_pred)
-    report(svm_ac, svm_matrix, svm_class_report)
-    seeMatrix(svm_matrix, svm.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startDecisionTree(X_train,X_test,y_train,y_test):
-    y_pred, dt = DecisionTree(X_train, X_test, y_train)
-    dt_ac, dt_matrix, dt_class_report = calculateMatrix(y_test, y_pred)
-    report(dt_ac, dt_matrix, dt_class_report)
-    seeMatrix(dt_matrix, dt.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startLogisticRegression(X_train,X_test,y_train,y_test):
-    y_pred, lr = LogisticRegress(X_train, X_test, y_train)
-    lr_ac, lr_matrix, lr_class_report = calculateMatrix(y_test, y_pred)
-    report(lr_ac, lr_matrix, lr_class_report)
-    seeMatrix(lr_matrix, lr.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startLinearSVC(X_train,X_test,y_train,y_test):
-    y_pred, svc = Linearsvc(X_train, X_test, y_train)
-    svc_ac, svc_matrix, svc_class_report = calculateMatrix(y_test, y_pred)
-    report(svc_ac, svc_matrix, svc_class_report)
-    seeMatrix(svc_matrix, svc.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)
-
-def startNaiveBayes(X_train,X_test,y_train,y_test):
-    y_pred, gnb = GaussianNaiveBayes(X_train, X_test, y_train)
-    gnb_ac, gnb_matrix, gnb_class_report = calculateMatrix(y_test, y_pred)
-    report(gnb_ac, gnb_matrix, gnb_class_report)
-    seeMatrix(gnb_matrix, gnb.classes_)
-    #rocCurve(y_test, y_pred)
-    #seeRocCurve(rf, X_train, y_train, 10)

startModel.py

@@ -0,0 +1,79 @@
+from models import *
+from analyse import *
+
+#Fonction permettant de calculer la matrice de confusion et les données liées à un entrainement et un test d'un model
+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 d'affichage de la 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 affichant les données clés à un model
+def report(accuracy,confMatrix,classReport):
+    print(f'Accuracy: {accuracy}')
+    print(f'Confusion Matrix:\n{confMatrix}')
+    print(f'Classification Report:\n{classReport}')
+
+#Fonction afin de récupérer le randomForest entrainé et savoir les donneés clés de l'entrainement
+def startRandomForest(X_train,X_test,y_train,y_test):
+    y_pred, rf = RandomForest(X_train, X_test, y_train)
+    rf_ac, rf_matrix, rf_class_report = calculateMatrix(y_test, y_pred)
+    report(rf_ac, rf_matrix, rf_class_report)
+    #seeMatrix(rf_matrix, rf.classes_)
+    return rf
+
+#Fonction afin de récupérer le KNN entrainé et savoir les donneés clés de l'entrainement
+def startKNN(X_train,X_test,y_train,y_test):
+    y_pred, knn = KNN(X_train, X_test, y_train)
+    knn_ac, knn_matrix, knn_class_report = calculateMatrix(y_test, y_pred)
+    report(knn_ac, knn_matrix, knn_class_report)
+    #seeMatrix(knn_matrix, knn.classes_)
+    return knn
+
+#Fonction afin de récupérer le SVM entrainé et savoir les donneés clés de l'entrainement
+def startSVM(X_train,X_test,y_train,y_test):
+    y_pred, svm = SVM(X_train, X_test, y_train)
+    svm_ac, svm_matrix, svm_class_report = calculateMatrix(y_test, y_pred)
+    report(svm_ac, svm_matrix, svm_class_report)
+    #seeMatrix(svm_matrix, svm.classes_)
+    return svm
+
+#Fonction afin de récupérer le DecisionTree entrainé et savoir les donneés clés de l'entrainement
+def startDecisionTree(X_train,X_test,y_train,y_test):
+    y_pred, dt = DecisionTree(X_train, X_test, y_train)
+    dt_ac, dt_matrix, dt_class_report = calculateMatrix(y_test, y_pred)
+    report(dt_ac, dt_matrix, dt_class_report)
+    #seeMatrix(dt_matrix, dt.classes_)
+    return dt
+
+#Fonction afin de récupérer la LogisticRegression entrainée et savoir les donneés clés de l'entrainement
+def startLogisticRegression(X_train,X_test,y_train,y_test):
+    y_pred, lr = LogisticRegress(X_train, X_test, y_train)
+    lr_ac, lr_matrix, lr_class_report = calculateMatrix(y_test, y_pred)
+    report(lr_ac, lr_matrix, lr_class_report)
+    #seeMatrix(lr_matrix, lr.classes_)
+    return lr
+
+#Fonction afin de récupérer la SVC Linear entrainée et savoir les donneés clés de l'entrainement
+def startLinearSVC(X_train,X_test,y_train,y_test):
+    y_pred, svc = Linearsvc(X_train, X_test, y_train)
+    svc_ac, svc_matrix, svc_class_report = calculateMatrix(y_test, y_pred)
+    report(svc_ac, svc_matrix, svc_class_report)
+    #seeMatrix(svc_matrix, svc.classes_)
+    return svc
+
+#Fonction afin de récupérer la Gaussian Naive Bayes entrainée et savoir les donneés clés de l'entrainement
+def startNaiveBayes(X_train,X_test,y_train,y_test):
+    y_pred, gnb = GaussianNaiveBayes(X_train, X_test, y_train)
+    gnb_ac, gnb_matrix, gnb_class_report = calculateMatrix(y_test, y_pred)
+    report(gnb_ac, gnb_matrix, gnb_class_report)
+    #seeMatrix(gnb_matrix, gnb.classes_)
+    return gnb
+