League of Legends prédicteur Win/Lose

League of Legends est un jeu 5 contre 5 joueurs en ligne. Le but du jeu étant de détruire la base adverse.

les notions importante a connaitre sur ce jeu pour comprendre le projet :

Au début de partie nous choisissons un personnage attribué pour cette partie (autrement appelé champion ou caractère) et on peut choisir de bannir un personnage pour l'interdire à l'équipe ennemie

Nous choisissons également des summoners (des sorts utilisable tous les 2 à 5 minute suivant le sort) ainsi que des runes (qui ne font pas parties de se projet)

Le but du jeu et de détruire le Nexux adverse (dernier bâtiments) pour ce faire il faut dans un premier temps détruire des tous qui le protège. Pour nous aider tout au long de la parties il y a des objectif qui apparaisse qui donne des statistique supplémentaire a tous les personnages de l'équipe qui les récupère il en existe 2 sortes :

Le Dragon récupérable 4 fois et l'Herald qui permet de détruire des bâtiments et après 20 minutes le Nashor donnant des "boost" temporaire mais très puissant

Et pour finir lorsque l'on est proche de détruire le NEXUS adverse on détruit tout d'abord des inhibiteurs qui donne un boost a l'équipe qui les détruit ont peut donc déjà en conclure que l'équipe ayant détruit le premier inhibiteurs a une grande chance de gagner et ca seras sans doute un élément important a prendre en compte.

Imports

import pandas as pd import requests import json from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score, classification_report from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import accuracy_score, classification_report, confusion_matrix from sklearn import tree from sklearn.ensemble import RandomForestClassifier import matplotlib.pyplot as plt import joblib from sklearn.tree import plot_tree

Run to view results

df = pd.read_csv('games.csv') print(f'Shape: {df.shape}') df.columns

Run to view results

On récupère les informations en format string qu'on a actuellement sous forme d'ID dans le CSV:

Champion Name

Key (id)

Tags (classes du champion support, tireur d'élite, tank, assassin, mage, combattant)

url = f"https://ddragon.leagueoflegends.com/cdn/13.23.1/data/en_US/champion.json" response = requests.get(url) data = response.json() champion_tuples = [(champion_name, int(champion_data["key"]), champion_data["tags"]) for champion_name, champion_data in data["data"].items()] champ_info_df = pd.DataFrame(champion_tuples, columns=["Champion Name", "Key", "Tags"]) print(champ_info_df)

Run to view results

Voici la répartition des différentes classe de champion sur le jeu

Run to view results

Tout d'abord essayons de voir le taux de victoire pour chaque personnage.

winner_list = [] loser_list = [] calcul_win_rate = [] for i in range(len(df)): if df['winner'][i] == 1: winner_list.append(df['t1_champ1id'][i]) winner_list.append(df['t1_champ2id'][i]) winner_list.append(df['t1_champ3id'][i]) winner_list.append(df['t1_champ4id'][i]) winner_list.append(df['t1_champ5id'][i]) loser_list.append(df['t2_champ1id'][i]) loser_list.append(df['t2_champ2id'][i]) loser_list.append(df['t2_champ3id'][i]) loser_list.append(df['t2_champ4id'][i]) loser_list.append(df['t2_champ5id'][i]) else: winner_list.append(df['t2_champ1id'][i]) winner_list.append(df['t2_champ2id'][i]) winner_list.append(df['t2_champ3id'][i]) winner_list.append(df['t2_champ4id'][i]) winner_list.append(df['t2_champ5id'][i]) loser_list.append(df['t1_champ1id'][i]) loser_list.append(df['t1_champ2id'][i]) loser_list.append(df['t1_champ3id'][i]) loser_list.append(df['t1_champ4id'][i]) loser_list.append(df['t1_champ5id'][i]) for i in range(len(champ_info_df['Key'])): #print(champ_info_df['Champion Name'][i]) if winner_list.count(champ_info_df['Key'][i]) != 0: win_rate = winner_list.count(champ_info_df['Key'][i]) / (winner_list.count(champ_info_df['Key'][i]) + loser_list.count(champ_info_df['Key'][i])) taux_pick = (((winner_list.count(champ_info_df['Key'][i]) + loser_list.count(champ_info_df['Key'][i]))/len(df))*100) calcul_win_rate.append((champ_info_df['Champion Name'][i], win_rate*100, taux_pick)) win_rate_df = pd.DataFrame(calcul_win_rate, columns=["Champion", "Win Rate (%)", "Pick Rate (%)"]) win_rate_df = win_rate_df.sort_values(by="Win Rate (%)") print(win_rate_df)

Run to view results

La disparité du taux de victoire entre les diffèrent personnage peut être expliqué par le souhait de riot games (studio créateur du jeu) de rendre fort certain champion durant des périodes pour donner de l'attrait au jeu et une impression de changement.

Maintenant essayons de voir si il y a un type de classe de personnages qui poserais problème (car trop fort ou trop faible)

from collections import Counter # tous dabord on recupere tous les tags pour les differents personnages key_to_tag = {key: champ_info_df.loc[champ_info_df['Key'] == key, 'Tags'].values[0] for key in champ_info_df['Key']} winner_comp_list = [] loser_comp_list = [] # On parcours 5 par 5 pour recuperer les compositions de base for i in range(0, len(winner_list), 5): segment_winner_list = winner_list[i:i+5] segment_loser_list = loser_list[i:i+5] tmp_winner_list = [key_to_tag[key][0] for key in segment_winner_list] # on les transforme en liste de tags tmp_loser_list = [key_to_tag[key][0] for key in segment_loser_list] # on les transforme en liste de tags winner_comp_list.append(tmp_winner_list) loser_comp_list.append(tmp_loser_list) # Aplatir la liste de listes pour compter les occurrences de chaque élément flattened_list = [item for sublist in winner_comp_list for item in sublist] flattened2_list = [item for sublist in loser_comp_list for item in sublist] # Utiliser Counter pour compter les occurrences de chaque élément occurrences_winner = Counter(flattened_list) occurrences_loser = Counter(flattened2_list) # Afficher les éléments les plus courants avec leur nombre d'occurrences most_common_elements = occurrences_winner.most_common() most_common_elements2 = occurrences_loser.most_common() print("Éléments les plus courants chez les gagnants :", most_common_elements) print("Éléments les plus courants chez les perdants :", most_common_elements2)

Run to view results

ont peut donc en conclure qu'il n'y a pas une classe qui fait plus perdre qu'une autre. Mais l'ont peut remarquer que la classe la plus joué est quasiment 3 fois plus joué que la moins joué qui est la classe assassin ici présent.

Regardons maintenant si des types de compositions peuvent être favorable on a décidé de ne prendre que le tags principal pour chaque personnage car certain personnage ayant 2 tags le premier étant celui qui lui correspond le mieux on a préfère garder que le premier pour éviter d'avoir un personnage : "tank/support" par exemple il seras considérer comme un tank

#transformation en set pour faciliter le travail winner_comp_list = [list(set(sublist)) for sublist in winner_comp_list] loser_comp_list = [list(set(sublist)) for sublist in loser_comp_list] #on compte les compositions des gagnants pour connaitre la plus presente list_occurrences = Counter(tuple(sublist) for sublist in winner_comp_list) #on la trie par ordre d'apparition sorted_lists = sorted(list_occurrences, key=lambda x: winner_comp_list.index(list(x))) #pareil pour les perdants list_occurrences2 = Counter(tuple(sublist) for sublist in loser_comp_list) sorted_lists2 = sorted(list_occurrences, key=lambda x: winner_comp_list.index(list(x))) # Créer un DataFrame pour les perdants data2 = {'Sublist': sorted_lists2, 'Occurrences': [list_occurrences2[sublist] for sublist in sorted_lists2]} df_loser = pd.DataFrame(data2) df_loser_sorted = df_loser.sort_values(by='Occurrences', ascending=False) #on met tous ca dans un dataframe data = {'Sublist': sorted_lists, 'Occurrences': [list_occurrences[sublist] for sublist in sorted_lists]} df_winner = pd.DataFrame(data) df_winner_sorted = df_winner.sort_values(by='Occurrences', ascending=False) # on ajoute le win rate df_winner_sorted['Win_Rate(%)'] = (df_winner_sorted['Occurrences'] / (df_winner_sorted['Occurrences'] + df_loser_sorted['Occurrences'])) * 100 #on les met ensemble merged_df = pd.merge(df_winner_sorted, df_loser_sorted, on='Sublist', suffixes=('_Winner', '_Loser')) # Calcul du win rate pour chaque sous-liste merged_df['Win_Rate(%)'] = (merged_df['Occurrences_Winner'] / (merged_df['Occurrences_Winner'] + merged_df['Occurrences_Loser'])) * 100 pd.set_option('display.width', 1000) #pour que ca s'affiche sur la meme ligne final_df = merged_df[['Sublist', 'Occurrences_Winner', 'Occurrences_Loser', 'Win_Rate(%)']] sorted_df = final_df.sort_values(by=['Win_Rate(%)', 'Occurrences_Winner'], ascending=False) filtered_df = sorted_df[(sorted_df['Occurrences_Winner'] > 250) | (sorted_df['Occurrences_Loser'] > 250)] print("DataFrame avec des occurrences supérieures à 250 :\n", filtered_df)

Run to view results

On voit assez rapidement qu'il n'y a pas de composition qui sort vraiment du lot, la seul analyse pertinente peut être qu'on remarque assez bien que plus la composition est varié plus elle a de chance de gagner surtout les teams sans support qui ont du mal et ont des pourcentage de victoire plus faible

Gaussienne du temps de jeu pour l'ensemble des parties

import seaborn as sns import matplotlib.pyplot as plt if 'gameDuration' in df.columns: plt.figure(figsize=(12, 8)) sns.set_theme(style="darkgrid") sns.histplot(data=(df['gameDuration']/60), bins=30, kde=True, color='skyblue') plt.title('Distribution of Game Duration', fontsize=16) plt.xlabel('Game Duration (minutes)', fontsize=14) plt.ylabel('Frequency', fontsize=14) plt.grid(axis='y', linestyle='--', alpha=0.7) plt.legend({'Kernel Density Estimate': df['gameDuration'].plot.kde()}, fontsize=12) # Réglage de l'échelle de l'axe x (de 0 à une valeur maximale souhaitée) plt.xlim(0, df['gameDuration'].max()/60) # Réglage de la limite maximale en minutes plt.show() else: print("'gameDuration' column is not present in the DataFrame.")

Run to view results

Ont peut remarqué que les parties sont assez équilibré au tour de 30 minutes, mais on a des parties inferieur a 15 minutes, on va supprimer les parties trop courte de notre dataset (parties inferieur à 15 minutes du a une personne qui abandonné la partie) donc pas pertinente

import seaborn as sns import matplotlib.pyplot as plt filtered_df = df[df['gameDuration'] >= 900] if 'gameDuration' in filtered_df.columns: plt.figure(figsize=(12, 8)) sns.set_theme(style="darkgrid") data=(filtered_df['gameDuration']/60) sns.histplot(data, bins=30, kde=True, color='skyblue') plt.title('Distribution of Game Duration', fontsize=16) plt.xlabel('Game Duration', fontsize=14) plt.ylabel('Frequency', fontsize=14) plt.grid(axis='y', linestyle='--', alpha=0.7) plt.legend({'Kernel Density Estimate': filtered_df['gameDuration'].plot.kde()}, fontsize=12) plt.xlim(0, filtered_df['gameDuration'].max()/60) plt.show() else: print("'gameDuration' column is not present in the DataFrame.")

Run to view results

On vérifie que notre dataset est équilibré en regardant le nombre de parties gagné et le nombre de parties perdu (car si 80% des parties sont gagner les résultats n'aurait pas été pertinent)

filtered_df['winner'].value_counts(normalize=True)

Run to view results

Maintenant on peut chercher les variables qui ont le plus d'impact sur la partie de jeu

La première chose à faire d'intéressante est d'afficher les statistique de base de chaque colonne

filtered_df.describe()

Run to view results

Maintenant à l'aide d'une headmap on regarde la corrélation des colonne par rapport à winner

winner_correlation = df.corr()['winner'].to_frame().T winner_correlation = winner_correlation.abs() threshold = 0.3 masked_correlation = winner_correlation.mask(abs(winner_correlation) < threshold) masked_correlation = masked_correlation.dropna(axis=1) masked_correlation = masked_correlation.T.sort_values(by='winner', ascending=False).T def color_cells(val): if val > 0.8: color = 'color: white; background-color: #3a00ff' elif val > 0.6: color = 'color: white; background-color: #7900ff' elif val > 0.4: color = 'color: white; background-color: #B300ff' else: color = 'color: white; background-color: #2596be' return color styled_heatmap = masked_correlation.style.applymap(color_cells) styled_heatmap

Run to view results

On utilise un meilleur affichage

import matplotlib.pyplot as plt import pandas as pd def color_cells(val): if val > 0.9: color = '#0d1364' elif val > 0.8: color = '#411181' elif val > 0.6: color = '#901bbb' elif val > 0.4: color = '#Bb1ba2' elif val > 0.3: color = '#1b8bbb' else: color = '#7ad0c8' return color sorted_corr = winner_correlation.iloc[0].sort_values() sorted_corr_filtered = sorted_corr[sorted_corr >= 0.2] colors = [color_cells(value) for value in sorted_corr_filtered] plt.figure(figsize=(10, 6)) plt.barh(sorted_corr_filtered.index, sorted_corr_filtered, color=colors) plt.xlabel('Corrélation avec "winner"') plt.title('Corrélation entre les colonnes et "winner"') plt.show()

Run to view results

TOP 10 meilleurs correlation avec en TOP 1 win qui a une correlation de 1 avec win (plutôt cohérent :) ) , le fait que l'herald, et le baron n'ait pas vraiment une grande importance et du au nombre de parties non négligeable ou aucune des 2 parties les prends.

TOP 10 des pires correlations

n_bottom_corr = 10 bottom_corr = winner_correlation.iloc[0].sort_values(ascending=True).head(n_bottom_corr) plt.figure(figsize=(10, 6)) plt.barh(bottom_corr.index, bottom_corr) plt.xlabel('Corrélation avec "winner"') plt.title(f'Les {n_bottom_corr} pires corrélations avec "winner"') plt.show()

Run to view results

Comme ont pouvait le deviner les champions bannis avant que la parties commence ne joue quasiment aucun rôle dans la corrélation avec la victoire, les summoners également car très souvent les mêmes et ne sont pas important.

Liste des elements qui ont le plus de d'importance. On voit qu'il y a des attributs du type t1_towerKills qui sont pas très intéressant car si une team gagne c'est logique d'avoir kill plus de tours que l'équipe ennemie. C'est pour ça que nous allons uniquement nous intéresser aux first objectifs.

correlation_threshold = 0.3 attributes = list(filter(lambda x: abs(float(winner_correlation[x])) > correlation_threshold, df.columns)) print("Liste des colonnes qui ont le plus d'importance :") print(attributes) objectives = list(filter(lambda x: 'first' in x, attributes)) print("Liste des objectifs :") print(objectives)

Run to view results

Affichons de manière plus graphique les objectifs interessant:

def calculate_percentage_wins(df, objective): total = df.shape[0] wins = df[df[objective] == df['winner']].shape[0] percentage_wins = round((wins / total) * 100, 2) percentage_loses = 100 - percentage_wins return percentage_wins, percentage_loses labels = [objective.replace('first', 'First ') for objective in objectives] percentages = [calculate_percentage_wins(df, objective)[0] for objective in objectives] fig, ax = plt.subplots(figsize=(10, 5)) bars = ax.barh(labels, percentages, color='skyblue') plt.xlabel('Pourcentage de victoires') plt.title('Pourcentage de victoires pour chaque objectif') for bar, percentage in zip(bars, percentages): ax.text(bar.get_width(), bar.get_y() + bar.get_height() / 2, f'{percentage}%', va='center', ha='left', fontsize=10, color='black') plt.show()

Run to view results

On prend seulement les attributs les plus important dans X et dans Y win or lose

colonnes_selectionnees_X = ['firstTower', 'firstInhibitor', 'firstDragon'] X = df[colonnes_selectionnees_X] colonnes_selectionnees_Y = ['winner'] Y = df[colonnes_selectionnees_Y] print(X.head()) print(Y.head())

Run to view results

Les X et Y sont one hot encodé

X_encoded = pd.get_dummies(X, columns=colonnes_selectionnees_X, prefix=colonnes_selectionnees_X, drop_first=True) print(X_encoded.head(10)) Y_encoded = pd.get_dummies(Y, columns=colonnes_selectionnees_Y, drop_first=True) print(Y_encoded.head(10))

Run to view results

INITIALISATION ensemble de test et train

X_train, X_test, y_train, y_test = train_test_split(X_encoded, Y_encoded, test_size=0.5, random_state=42) y_train = y_train.values.ravel() y_test = y_test.values.ravel()

Run to view results

KNN voisins sur ces données

accuracies = [] for k in range(1, 10): knn_model = KNeighborsClassifier(n_neighbors=k) knn_model.fit(X_train, y_train) y_pred = knn_model.predict(X_test) accuracy = accuracy_score(y_test, y_pred) accuracies.append(accuracy) print(f"Nombre de voisins (k = {k}): Accuracy = {accuracy:.2f}")

Run to view results

Arbre

def arbre(): modele_arbre_decision = DecisionTreeClassifier(random_state=42) # entrainement de l'arbre modele_arbre_decision.fit(X_train, y_train) # Prédiction sur l'ensemble de test predictions = modele_arbre_decision.predict(X_test) # Évaluation du modèle accuracy = accuracy_score(y_test, predictions) print(f"Précision du modèle : {accuracy * 100:.2f}%") # Affichage de la matrice de confusion et du rapport de classification print("\nMatrice de confusion :\n", confusion_matrix(y_test, predictions)) print("\nRapport de classification :\n", classification_report(y_test, predictions)) # Visualisation de l'arbre avec matplotlib plt.figure(figsize=(20,10)) plot_tree(modele_arbre_decision, feature_names=X_train.columns, # Assurez-vous de remplacer 'X_train' par votre ensemble de données class_names=list(map(str, modele_arbre_decision.classes_)), filled=True, rounded=True) plt.show() arbre()

Run to view results

Random Forest (on affiche 3 arbres pour mieux montrer le côté aléatoire)

def foretArbresAleatoire(): foret_arbres = RandomForestClassifier(n_estimators=100, random_state=42) foret_arbres.fit(X_train, y_train) predictions = foret_arbres.predict(X_test) accuracy = accuracy_score(y_test, predictions) print(f"Précision du modèle : {accuracy * 100:.2f}%") print("\nRapport de classification :\n", classification_report(y_test, predictions)) for i, arbre in enumerate(foret_arbres.estimators_): plt.figure(figsize=(20, 10)) plot_tree(arbre, feature_names=X_train.columns, # Assurez-vous de remplacer 'X_train' par votre ensemble de données class_names=list(map(str, foret_arbres.classes_)), filled=True, rounded=True, max_depth=3) # Limitez la profondeur pour une visualisation plus claire plt.title(f"Arbre {i+1} de la forêt d'arbres aléatoires") plt.show() if i == 2: break foretArbresAleatoire()

Run to view results

Réseaux de Neurones

import pandas as pd import numpy as np import tensorflow as tf from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, classification_report tf.get_logger().setLevel('ERROR') # Convertir les données en tableaux NumPy X_train = np.array(X_train) X_test = np.array(X_test) y_train = np.array(y_train) y_test = np.array(y_test) model = tf.keras.Sequential([ tf.keras.layers.Dense(128, activation='relu', input_shape=(X_train.shape[1],)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(X_train, y_train, epochs=3, batch_size=32, validation_data=(X_test, y_test)) y_pred_proba = model.predict(X_test) y_pred = (y_pred_proba > 0.5).astype(int) accuracy = accuracy_score(y_test, y_pred) classification_rep = classification_report(y_test, y_pred) print(f"Accuracy: {accuracy:.2f}") print("Classification Report:\n", classification_rep)

Run to view results

Nos résultats sont corrects mais ils prennent en compte "firstInibitor" qui est pris en fin de partie contrairement à "firstTower" et "firstDragon" qui ont plus tendance à apparaître en début de partie. Donc on va essayer de voir ce que le modèle va donner avec seulement les données de début de parties( ~avant 15 minutes de jeu). Ici on le fait avec KNN

colonnes_selectionnees_X = ['firstTower', 'firstDragon'] X = df[colonnes_selectionnees_X] colonnes_selectionnees_Y = ['winner'] Y = df[colonnes_selectionnees_Y] X_encoded = pd.get_dummies(X, columns=colonnes_selectionnees_X, prefix=colonnes_selectionnees_X, drop_first=True) Y_encoded = pd.get_dummies(Y, columns=colonnes_selectionnees_Y, drop_first=True) import pandas as pd from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score, classification_report import matplotlib.pyplot as plt X_train, X_test, y_train, y_test = train_test_split(X_encoded, Y_encoded, test_size=0.5, random_state=42) y_train = y_train.values.ravel() y_test = y_test.values.ravel() accuracies = [] for k in range(1, 10): knn_model = KNeighborsClassifier(n_neighbors=k) knn_model.fit(X_train, y_train) y_pred = knn_model.predict(X_test) accuracy = accuracy_score(y_test, y_pred) accuracies.append(accuracy) print(f"Nombre de voisins (k = {k}): Accuracy = {accuracy:.2f}")

Run to view results

On va essayer de faire des predictions avec cette fois seulement avec les informations d'avant game

colonnes_selectionnees_X = ['firstBlood', 't1_champ1id', 't1_champ2id', 't1_champ3id', 't1_champ4id', 't1_champ5id', 't2_champ1id', 't2_champ2id', 't2_champ3id', 't2_champ4id', 't2_champ5id','t1_champ1_sum1', 't1_champ1_sum2', 't1_champ2_sum1', 't1_champ2_sum2', 't1_champ3_sum1', 't1_champ3_sum2', 't1_champ4_sum1', 't1_champ4_sum2','t1_champ5_sum1', 't1_champ5_sum2', 't2_champ1_sum1',] X = df[colonnes_selectionnees_X] colonnes_selectionnees_Y = ['winner'] Y = df[colonnes_selectionnees_Y] X_encoded = pd.get_dummies(X, columns=colonnes_selectionnees_X, prefix=colonnes_selectionnees_X, drop_first=True) print(X_encoded.head(10)) Y_encoded = pd.get_dummies(Y, columns=colonnes_selectionnees_Y, drop_first=True) print(Y_encoded.head(10))

Run to view results

X_train, X_test, y_train, y_test = train_test_split(X_encoded, Y_encoded, test_size=0.5, random_state=42) y_train = y_train.values.ravel() y_test = y_test.values.ravel() accuracies = [] for k in range(1, 10): # Créer le modèle k-NN knn_model = KNeighborsClassifier(n_neighbors=k) # Entraîner le modèle knn_model.fit(X_train, y_train) # Faire des prédictions sur l'ensemble de test y_pred = knn_model.predict(X_test) # Calculer l'accuracy accuracy = accuracy_score(y_test, y_pred) accuracies.append(accuracy) print(f"Nombre de voisins (k = {k}): Accuracy = {accuracy:.2f}")

Run to view results

X_train = np.array(X_train) X_test = np.array(X_test) y_train = np.array(y_train) y_test = np.array(y_test) model = tf.keras.Sequential([ tf.keras.layers.Dense(128, activation='relu', input_shape=(X_train.shape[1],)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test)) y_pred_proba = model.predict(X_test) y_pred = (y_pred_proba > 0.5).astype(int) accuracy = accuracy_score(y_test, y_pred) classification_rep = classification_report(y_test, y_pred) print(f"Accuracy: {accuracy:.2f}") print("Classification Report:\n", classification_rep)

Run to view results

Naive Bayes

from sklearn.naive_bayes import GaussianNB nb_classifier = GaussianNB() nb_classifier.fit(X_train, y_train) y_pred = nb_classifier.predict(X_test) accuracy = accuracy_score(y_test, y_pred) classification_rep = classification_report(y_test, y_pred) print(f"Accuracy: {accuracy:.2f}") print("Classification Report:\n", classification_rep)

Run to view results