Temps d'exécution des classifieurs

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression

models = {
    'KNN': KNeighborsClassifier(weights='uniform', algorithm='auto'),
    'KNN Distance Weighted': KNeighborsClassifier(weights='distance', algorithm='auto'),
    'DecisionTree': DecisionTreeClassifier(),
    'RandomForest': RandomForestClassifier(),
    'AdaBoost': AdaBoostClassifier(),
    'GradientBoosting': GradientBoostingClassifier(),
    'SVM linear': SVC(kernel='linear'),
    'SVM rbf': SVC(kernel='rbf'),
    'SVM poly': SVC(kernel='poly'),
    'SVM sigmoid': SVC(kernel='sigmoid'),
    'LogisticRegression': LogisticRegression()
}

import time
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

dataset_sizes = [10000]
n_features = 10

time_results = []

def evaluate_execution_time(model, X_train, y_train):
    start_time = time.time()
    model.fit(X_train, y_train)
    end_time = time.time()
    return end_time - start_time

# Génération des datasets et benchmark
for size in dataset_sizes:
    X, y = make_classification(n_samples=size, n_features=n_features, random_state=42)
    
    for model_name, model in models.items():
        times = []
        for _ in range(5):
            exec_time = evaluate_execution_time(model, X, y)
            times.append(exec_time)
        
        avg_time = np.mean(times)
        time_results.append({
            'Model': model_name,
            'Dataset Size': size,
            'Average Execution Time (s)': avg_time
        })

df = pd.DataFrame(time_results)
df = df.round(3)
df = df.sort_values(by=['Dataset Size', 'Average Execution Time (s)'], ascending=True)
df