iris = load_iris()
X = iris.data
y = iris.target
k = 5  # number of folds
n_samples = X.shape[0]  # number of samples
fold_size = n_samples // k  # size of each fold
knn = KNeighborsClassifier(n_neighbors=k)
scores = []  # to store the scores for each fold
indices = np.random.permutation(n_samples)  # shuffle the indices
indices

folds = [indices[i*fold_size:(i+1)*fold_size] for i in range(k)]
folds

for i in range(k):
    test_indices = folds[i]
    train_indices = np.concatenate([folds[j]
                                   for j in range(k) if j != i], axis=0)
    X_train, y_train = X[train_indices], y[train_indices]
    X_test, y_test = X[test_indices], y[test_indices]
    knn.fit(X_train, y_train)
    score = knn.score(X_test, y_test)
    scores.append(score)
scores

from sklearn.model_selection import cross_val_score
scores = cross_val_score(knn, X, y, cv=k)
scores

from sklearn.model_selection import learning_curve

import matplotlib.pyplot as plt

train_sizes, train_scores, test_scores = learning_curve(
    knn, X, y, cv=k, n_jobs=-1, train_sizes=np.linspace(0.1, 1.0, 10)
)
train_sizes, train_scores, test_scores

train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
train_scores_mean, train_scores_std, test_scores_mean, test_scores_std

plt.figure()
plt.title("Learning Curve")
plt.xlabel("Training examples")
plt.ylabel("Score")
plt.grid()

plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
                 train_scores_mean + train_scores_std, alpha=0.1,
                 color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
                 test_scores_mean + test_scores_std, alpha=0.1, color="g")

plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
         label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
         label="Cross-validation score")

plt.legend(loc="best")
plt.show()

from sklearn.model_selection import validation_curve
param_range = np.arange(1, 10)

train_scores, test_scores = validation_curve(
    knn, X, y, param_name='n_neighbors', param_range=param_range,
    cv=5, scoring="accuracy", n_jobs=-1
)

# 计算训练集和验证集的平均得分
train_scores_mean = np.mean(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)

# 绘制验证曲线
plt.figure(figsize=(8, 6))
plt.plot(param_range, train_scores_mean, label="Training score", color="r")
plt.plot(param_range, test_scores_mean,
         label="Cross-validation score", color="g")

# 设置图形属性
plt.title(f"Validation Curve with KNN (n_neighbors)")
plt.xlabel("n_neighbors")
plt.ylabel("Accuracy")
plt.xscale("log")  # 对数尺度
plt.legend(loc="best")
plt.grid(True)
plt.show()

from sklearn.model_selection import KFold
model = knn
param_name = 'n_neighbors'
param_range = np.arange(1, 10)
# 初始化存储得分的数组
train_scores = []
test_scores = []
for param_value in param_range:
    # 设置超参数
    model.set_params(**{param_name: param_value})

    # 初始化当前超参数值的得分
    train_fold_scores = []
    test_fold_scores = []

    # 使用 KFold 交叉验证
    kf = KFold(n_splits=5, shuffle=True, random_state=42)
    for train_index, test_index in kf.split(X):
        X_train, X_test = X[train_index], X[test_index]
        y_train, y_test = y[train_index], y[test_index]

        # 训练模型
        model.fit(X_train, y_train)

        # 计算训练集和验证集得分
        train_score = model.score(X_train, y_train)
        test_score = model.score(X_test, y_test)

        # 保存当前 fold 的得分
        train_fold_scores.append(train_score)
        test_fold_scores.append(test_score)

    # 计算当前超参数值的平均得分
    train_scores.append(np.mean(train_fold_scores))
    test_scores.append(np.mean(test_fold_scores))

    print(
        f"param_value: {param_value}, train_scores: {train_scores[-1]}, test_scores: {test_scores[-1]}")

train_scores, test_scores = [], []
train_sizes = np.arange(0.1, 1.0, 0.1)
n_samples = X.shape[0]
for train_size in train_sizes:
    train_subset = int(n_samples * train_size)
    X_train, X_test = X[:train_subset], X[train_subset:]
    y_train, y_test = y[:train_subset], y[train_subset:]
    model.fit(X_train, y_train)
    train_scores.append(model.score(X_train, y_train))
    test_scores.append(model.score(X_test, y_test))
print(train_scores, test_scores)