如何计算Scikit-learn模型运行时间？多算法速度评估方法

我已完成Logistic Regression模型的构建与性能评估，相关代码如下：

# 创建存储模型性能结果的容器
ML_Model = []
accuracy = []
f1_score = []
recall = []
precision = []

# 用于存储结果的函数
def storeResults(model, a,b,c,d):
  ML_Model.append(model)
  accuracy.append(round(a, 3))
  f1_score.append(round(b, 3))
  recall.append(round(c, 3))
  precision.append(round(d, 3))

# 逻辑回归模型
from sklearn.linear_model import LogisticRegression
#from sklearn.pipeline import Pipeline

# 实例化模型
log = LogisticRegression()

# 训练模型
log.fit(X_train,y_train)
# 对样本进行目标值预测
y_train_log = log.predict(X_train)
y_test_log = log.predict(X_test)

# 计算模型性能指标：准确率、F1分数、召回率、精确率
acc_train_log = metrics.accuracy_score(y_train,y_train_log)
acc_test_log = metrics.accuracy_score(y_test,y_test_log)
print("Logistic Regression : 训练集准确率: {:.3f}".format(acc_train_log))
print("Logistic Regression : 测试集准确率: {:.3f}".format(acc_test_log))
print()

f1_score_train_log = metrics.f1_score(y_train,y_train_log)
f1_score_test_log = metrics.f1_score(y_test,y_test_log)
print("Logistic Regression : 训练集F1分数: {:.3f}".format(f1_score_train_log))
print("Logistic Regression : 测试集F1分数: {:.3f}".format(f1_score_test_log))
print()

recall_score_train_log = metrics.recall_score(y_train,y_train_log)
recall_score_test_log = metrics.recall_score(y_test,y_test_log)
print("Logistic Regression : 训练集召回率: {:.3f}".format(recall_score_train_log))
print("Logistic Regression : 测试集召回率: {:.3f}".format(recall_score_test_log))
print()

precision_score_train_log = metrics.precision_score(y_train,y_train_log)
precision_score_test_log = metrics.precision_score(y_test,y_test_log)
print("Logistic Regression : 训练集精确率: {:.3f}".format(precision_score_train_log))
print("Logistic Regression : 测试集精确率: {:.3f}".format(precision_score_test_log))

模型性能输出结果：

Logistic Regression : 训练集准确率: 0.927
Logistic Regression : 测试集准确率: 0.934

Logistic Regression : 训练集F1分数: 0.935
Logistic Regression : 测试集F1分数: 0.941

Logistic Regression : 训练集召回率: 0.943
Logistic Regression : 测试集召回率: 0.953

Logistic Regression : 训练集精确率: 0.927
Logistic Regression : 测试集精确率: 0.930

同时生成了分类报告，代码如下：

# 计算模型的分类报告
print(metrics.classification_report(y_test, y_test_log))

分类报告输出：

precision    recall  f1-score   support
0       0.94      0.91      0.92       976
1       0.93      0.95      0.94      1235
accuracy                           0.93      2211
macro avg       0.93      0.93      0.93      2211
weighted avg       0.93      0.93      0.93      2211

我还需要计算Logistic Regression模型及KNN、Support Vector Classifier等其他机器学习模型的运行时间，以此了解算法运行速度，进而选择合适的算法，请问该如何实现？

要对比不同模型的运行速度，重点统计训练时间和预测时间两个核心阶段即可，用Python内置的time模块就能实现，以下是具体方案：

1. 基础实现逻辑 #

在模型训练、预测的前后分别记录时间戳，两者的差值就是对应阶段的耗时。同时可以扩展原有结果存储逻辑，把时间指标和性能指标整合在一起，方便后续对比。

2. 代码实现示例 #

2.1 扩展结果存储机制 #

先新增存储时间的容器，修改结果存储函数：

# 扩展存储容器，加入时间指标
ML_Model = []
accuracy = []
f1_score = []
recall = []
precision = []
train_time = []  # 训练耗时（秒）
predict_time = []  # 预测耗时（秒）

# 扩展存储函数，新增时间参数
def storeResults(model, acc, f1, rec, pre, t_train, t_predict):
    ML_Model.append(model)
    accuracy.append(round(acc, 3))
    f1_score.append(round(f1, 3))
    recall.append(round(rec, 3))
    precision.append(round(pre, 3))
    train_time.append(round(t_train, 4))
    predict_time.append(round(t_predict, 4))

2.2 为Logistic Regression添加计时 #

修改原有逻辑回归代码，嵌入计时步骤：

import time
from sklearn.linear_model import LogisticRegression
from sklearn import metrics

# 实例化模型
log = LogisticRegression()

# 训练阶段计时
start_train = time.time()
log.fit(X_train, y_train)
train_duration = time.time() - start_train

# 预测阶段计时
start_predict = time.time()
y_test_log = log.predict(X_test)
predict_duration = time.time() - start_predict

# 计算性能指标
acc_test = metrics.accuracy_score(y_test, y_test_log)
f1_test = metrics.f1_score(y_test, y_test_log)
recall_test = metrics.recall_score(y_test, y_test_log)
precision_test = metrics.precision_score(y_test, y_test_log)

# 存储结果
storeResults("Logistic Regression", acc_test, f1_test, recall_test, precision_test, train_duration, predict_duration)

2.3 KNN和SVC模型的计时实现 #

按照同样逻辑，对KNN和支持向量机进行计时：

# KNN模型计时
from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)
# 训练计时
start_train = time.time()
knn.fit(X_train, y_train)
train_duration_knn = time.time() - start_train
# 预测计时
start_predict = time.time()
y_test_knn = knn.predict(X_test)
predict_duration_knn = time.time() - start_predict
# 计算指标并存储
acc_test_knn = metrics.accuracy_score(y_test, y_test_knn)
f1_test_knn = metrics.f1_score(y_test, y_test_knn)
recall_test_knn = metrics.recall_score(y_test, y_test_knn)
precision_test_knn = metrics.precision_score(y_test, y_test_knn)
storeResults("KNN", acc_test_knn, f1_test_knn, recall_test_knn, precision_test_knn, train_duration_knn, predict_duration_knn)

# SVC模型计时
from sklearn.svm import SVC

svc = SVC()
# 训练计时
start_train = time.time()
svc.fit(X_train, y_train)
train_duration_svc = time.time() - start_train
# 预测计时
start_predict = time.time()
y_test_svc = svc.predict(X_test)
predict_duration_svc = time.time() - start_predict
# 计算指标并存储
acc_test_svc = metrics.accuracy_score(y_test, y_test_svc)
f1_test_svc = metrics.f1_score(y_test, y_test_svc)
recall_test_svc = metrics.recall_score(y_test, y_test_svc)
precision_test_svc = metrics.precision_score(y_test, y_test_svc)
storeResults("SVC", acc_test_svc, f1_test_svc, recall_test_svc, precision_test_svc, train_duration_svc, predict_duration_svc)

2.4 生成对比表格 #

用pandas把所有结果整理成表格，直观对比性能与速度：

import pandas as pd

results_df = pd.DataFrame({
    "模型": ML_Model,
    "准确率": accuracy,
    "F1分数": f1_score,
    "召回率": recall,
    "精确率": precision,
    "训练耗时(s)": train_time,
    "预测耗时(s)": predict_time
})

print(results_df)

3. 注意事项 #

• 若模型运行极快，单次计时误差大，可以用timeit模块多次运行取平均值：

  import timeit
  # 重复训练5次取平均耗时
  avg_train_time = timeit.timeit(lambda: log.fit(X_train,y_train), number=5)/5
  

• 计时时尽量排除无关代码干扰，只统计模型训练、预测的核心耗时。

内容的提问来源于stack exchange，提问作者bat