📋 このステップで学ぶこと
なぜ交差検証が必要か
K-Fold交差検証の仕組み
Stratified K-Fold（層化交差検証）
Leave-One-Out交差検証
cross_val_scoreの使い方
交差検証の実践的な活用法
演習問題： 8問
🎯 1. なぜ交差検証が必要か
STEP 5で学んだホールドアウト法（データを訓練とテストに1回だけ分割する方法）には、いくつかの問題があります。まず、その問題点を確認してみましょう。
ホールドアウト法の問題点
⚠️ ホールドアウト法の3つの限界
問題1： 評価結果がデータの分割方法に依存する（運任せになる）問題2： データが少ないと、訓練データが不足して学習が不十分になる問題3： 1回の評価では統計的な信頼性が低い
これらの問題を実際にコードで確認してみましょう。同じデータを使っても、分割の仕方（random_state）を変えるだけで結果が大きく変わることがわかります。
コードの準備：必要なライブラリの読み込み
まず、必要なライブラリをインポートします。
numpy：数値計算（平均や標準偏差の計算）に使用load_iris：練習用のアヤメデータセットを読み込む関数train_test_split：データを訓練とテストに分割する関数LogisticRegression：分類に使うモデル（ロジスティック回帰）
# ライブラリのインポート
import numpy as np # 数値計算ライブラリ
from sklearn.datasets import load_iris # サンプルデータセット
from sklearn.model_selection import train_test_split # データ分割
from sklearn.linear_model import LogisticRegression # 分類モデル
ホールドアウト法の問題を確認する
同じデータを5回分割して、結果がどれだけばらつくか確認します。
random_state=seed：乱数のシード値を変えることで、異なる分割を作成test_size=0.3：全データの30%をテストデータに使用model.score()：テストデータでの正解率を計算
# Irisデータセットを読み込む
iris = load_iris()
X, y = iris.data, iris.target # X:特徴量(150×4), y:ラベル(150)
# 異なるrandom_stateで5回評価してみる
scores = [] # スコアを保存するリスト
for seed in range(5): # seed: 0, 1, 2, 3, 4
# データを分割（seedを変えると分割の仕方が変わる）
X_train, X_test, y_train, y_test = train_test_split(
X, y, # 分割するデータ
test_size=0.3, # 30%をテストに使用
random_state=seed # 乱数シード（これを変えると結果が変わる）
)
# モデルを作成して訓練
model = LogisticRegression(max_iter=1000) # max_iter:最大反復回数
model.fit(X_train, y_train) # 訓練データで学習
# テストデータで評価
score = model.score(X_test, y_test) # 正解率を計算
scores.append(score) # リストに追加
# 結果を表示
print(“ホールドアウト法（5回実行）:”)
print(f” スコア: {scores}”)
print(f” 平均: {np.mean(scores):.4f}”)
print(f” 標準偏差: {np.std(scores):.4f}”)
print(f” 範囲: {min(scores):.4f} 〜 {max(scores):.4f}”)
ホールドアウト法（5回実行）:
スコア: [0.9778, 0.9556, 0.9778, 1.0000, 0.9556]
平均: 0.9733
標準偏差: 0.0178
範囲: 0.9556 〜 1.0000
💡 結果の解釈
同じデータ・同じモデルなのに、分割の仕方を変えるだけでスコアが95.56%〜100% と大きく変動しています。交差検証（Cross-Validation） です。
交差検証の考え方
📊 交差検証のアイデア
「全データを訓練にも評価にも使う」ことで、より安定した評価を得る。
具体的には：
📊 2. K-Fold交差検証
K-Fold交差検証は、最も基本的で広く使われる交差検証の方法です。「K」は分割するグループの数を表します（通常5か10が使われます）。
K-Fold CVの仕組み
🔄 K-Fold CVの4ステップ
ステップ1： データをK個のグループ（fold）に均等に分割ステップ2： 1つのfoldをテスト、残りK-1個を訓練データとして使用ステップ3： これをK回繰り返す（各foldが1回ずつテストになる）ステップ4： K個のスコアの平均を最終スコアとする
【5-Fold CVのイメージ（K=5の場合）】
データを5つのグループに分割し、順番にテストに使う：
Fold 1: [テスト] [訓練] [訓練] [訓練] [訓練] → スコア1を計算
Fold 2: [訓練] [テスト] [訓練] [訓練] [訓練] → スコア2を計算
Fold 3: [訓練] [訓練] [テスト] [訓練] [訓練] → スコア3を計算
Fold 4: [訓練] [訓練] [訓練] [テスト] [訓練] → スコア4を計算
Fold 5: [訓練] [訓練] [訓練] [訓練] [テスト] → スコア5を計算
最終スコア = (スコア1 + スコア2 + スコア3 + スコア4 + スコア5) / 5
→ 全データが1回ずつテストに使われる！
→ 評価が特定の分割に依存しない！
KFoldクラスの使い方
KFoldクラスのパラメータを理解しましょう。
n_splits=5：データを5つのグループに分割（5-Fold CV）shuffle=True：分割前にデータをシャッフルする（推奨）random_state=42：シャッフルの乱数シード（再現性のため）
# KFoldクラスをインポート
from sklearn.model_selection import KFold
# KFoldオブジェクトを作成
kfold = KFold(
n_splits=5, # 5分割（5-Fold CV）
shuffle=True, # データをシャッフルしてから分割
random_state=42 # 乱数シード（結果の再現性のため）
)
# split()メソッドで分割のインデックスを取得
print(“5-Fold CVの分割を確認:”)
for fold, (train_idx, test_idx) in enumerate(kfold.split(X)):
# fold: 何回目の分割か（0, 1, 2, 3, 4）
# train_idx: 訓練データのインデックス（配列）
# test_idx: テストデータのインデックス（配列）
print(f” Fold {fold+1}: 訓練={len(train_idx)}件, テスト={len(test_idx)}件”)
5-Fold CVの分割を確認:
Fold 1: 訓練=120件, テスト=30件
Fold 2: 訓練=120件, テスト=30件
Fold 3: 訓練=120件, テスト=30件
Fold 4: 訓練=120件, テスト=30件
Fold 5: 訓練=120件, テスト=30件
✅ ポイント
Irisデータは150件なので、5分割すると各foldは30件になります。
K-Fold CVを手動で実行する
実際にK-Fold CVでモデルを評価してみましょう。
各foldで「訓練→評価」を繰り返し、最後に平均スコアを計算します。
# K-Fold CVを手動で実行
scores = [] # 各foldのスコアを保存
# kfold.split(X)で分割のインデックスを取得し、順番に処理
for fold, (train_idx, test_idx) in enumerate(kfold.split(X)):
# インデックスを使ってデータを分割
X_train, X_test = X[train_idx], X[test_idx] # 特徴量の分割
y_train, y_test = y[train_idx], y[test_idx] # ラベルの分割
# モデルを新しく作成（各foldで初期化）
model = LogisticRegression(max_iter=1000)
# 訓練データで学習
model.fit(X_train, y_train)
# テストデータで評価
score = model.score(X_test, y_test)
scores.append(score)
print(f”Fold {fold+1}: {score:.4f}”)
# 最終結果（平均と標準偏差）
print(f”\n平均スコア: {np.mean(scores):.4f} (±{np.std(scores):.4f})”)
Fold 1: 0.9667
Fold 2: 1.0000
Fold 3: 0.9333
Fold 4: 0.9667
Fold 5: 1.0000
平均スコア: 0.9733 (±0.0249)
💡 結果の解釈
5つのfoldのスコア（93.33%〜100%）の平均97.33% が、このモデルの推定性能です。
⚡ 3. cross_val_score（便利な関数）
毎回forループを書くのは面倒ですよね。scikit-learnには、交差検証を1行で実行できる便利な関数 があります。
cross_val_scoreの基本
cross_val_scoreの引数を理解しましょう。
model：評価したいモデル（未訓練でOK）X：特徴量データy：正解ラベルcv=5：分割数（5-Fold CV）
戻り値： 各foldのスコアが入った配列
# cross_val_scoreをインポート
from sklearn.model_selection import cross_val_score
# モデルを作成（まだ訓練しない）
model = LogisticRegression(max_iter=1000)
# cross_val_scoreで5-Fold CVを実行
# この1行で、前のセクションのforループと同じことができる！
scores = cross_val_score(
model, # 評価したいモデル
X, # 特徴量
y, # 正解ラベル
cv=5 # 5-Fold CV
)
# 結果を表示
print(“cross_val_scoreの結果:”)
print(f” 各Foldのスコア: {scores}”)
print(f” 平均: {scores.mean():.4f}”)
print(f” 標準偏差: {scores.std():.4f}”)
cross_val_scoreの結果:
各Foldのスコア: [0.9667 1. 0.9333 0.9667 1. ]
平均: 0.9733
標準偏差: 0.0249
異なる評価指標を使用する
scoringパラメータで評価指標を変更できます。
scoring='accuracy'：正解率（デフォルト）scoring='f1_macro'：F1スコア（マクロ平均）scoring='roc_auc_ovr'：ROC-AUC（多クラス用）
# 異なる評価指標で交差検証
# 正解率（accuracy）- デフォルト
scores_acc = cross_val_score(model, X, y, cv=5, scoring=’accuracy’)
# F1スコア（マクロ平均）- クラスごとのF1を平均
scores_f1 = cross_val_score(model, X, y, cv=5, scoring=’f1_macro’)
# ROC-AUC（One-vs-Rest）- 多クラス分類用
scores_auc = cross_val_score(model, X, y, cv=5, scoring=’roc_auc_ovr’)
print(“異なる評価指標での交差検証:”)
print(f” Accuracy: {scores_acc.mean():.4f} (±{scores_acc.std():.4f})”)
print(f” F1-macro: {scores_f1.mean():.4f} (±{scores_f1.std():.4f})”)
print(f” ROC-AUC: {scores_auc.mean():.4f} (±{scores_auc.std():.4f})”)
問題タイプ
scoring値
説明
分類
'accuracy'正解率（最も基本的）
分類
'f1', 'f1_macro'F1スコア（不均衡データ向け）
分類
'precision', 'recall'適合率、再現率
分類
'roc_auc'ROC-AUC
回帰
'r2'決定係数（R²）
回帰
'neg_mean_squared_error'MSEの負値
回帰
'neg_root_mean_squared_error'RMSEの負値
⚠️ 回帰の評価指標に「neg_」がつく理由
scikit-learnでは「スコアは大きいほど良い」というルールがあります。
📈 4. Stratified K-Fold（層化交差検証）
通常のK-Foldには1つ問題があります。クラスの比率が各foldで異なる可能性がある ことです。これは特に不均衡データで問題になります。
通常のKFoldの問題点
不均衡データ（クラス比率が偏ったデータ）で何が起こるか見てみましょう。
クラス0が90%、クラス1が10%のデータを作成して、通常のKFoldとStratified KFoldを比較します。
# 通常のKFold vs Stratified KFoldの比較
from sklearn.model_selection import KFold, StratifiedKFold
import numpy as np
# 不均衡データを作成（クラス0:90%, クラス1:10%）
y_imbalanced = np.array([0]*90 + [1]*10) # 0が90個、1が10個
X_dummy = np.random.randn(100, 2) # ダミーの特徴量
print(“元データのクラス比率:”)
print(f” クラス0: {sum(y_imbalanced==0)/len(y_imbalanced)*100:.0f}%”)
print(f” クラス1: {sum(y_imbalanced==1)/len(y_imbalanced)*100:.0f}%”)
# 通常のKFoldでの分割
print(“\n【通常のKFold】”)
kfold = KFold(n_splits=5, shuffle=True, random_state=42)
for fold, (_, test_idx) in enumerate(kfold.split(X_dummy)):
y_test = y_imbalanced[test_idx]
ratio_class1 = sum(y_test==1) / len(y_test) * 100
print(f” Fold {fold+1}: クラス1の比率 = {ratio_class1:.0f}%”)
元データのクラス比率:
クラス0: 90%
クラス1: 10%
【通常のKFold】
Fold 1: クラス1の比率 = 15%
Fold 2: クラス1の比率 = 5%
Fold 3: クラス1の比率 = 10%
Fold 4: クラス1の比率 = 15%
Fold 5: クラス1の比率 = 5%
⚠️ 問題発見！
元データでは「クラス1が10%」なのに、foldによって5%〜15%とばらついています。
Stratified K-Foldの使い方
Stratified K-Foldは、各foldでクラス比率を維持します。
使い方はKFoldとほぼ同じですが、split()にyも渡す必要があります。
# Stratified KFoldでの分割
print(“【Stratified KFold】”)
skfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# 注意: split()にX, y両方を渡す（yを見てクラス比率を維持するため）
for fold, (_, test_idx) in enumerate(skfold.split(X_dummy, y_imbalanced)):
y_test = y_imbalanced[test_idx]
ratio_class1 = sum(y_test==1) / len(y_test) * 100
print(f” Fold {fold+1}: クラス1の比率 = {ratio_class1:.0f}%”)
【Stratified KFold】
Fold 1: クラス1の比率 = 10%
Fold 2: クラス1の比率 = 10%
Fold 3: クラス1の比率 = 10%
Fold 4: クラス1の比率 = 10%
Fold 5: クラス1の比率 = 10%
✅ 完璧！
全てのfoldで「クラス1が10%」という元データの比率が維持されています。
cross_val_scoreでStratified K-Foldを使う方法：
cvパラメータにStratifiedKFoldオブジェクトを渡すだけです。
# cross_val_scoreでStratified KFoldを使用
from sklearn.model_selection import cross_val_score, StratifiedKFold
model = LogisticRegression(max_iter=1000)
# StratifiedKFoldオブジェクトを作成
cv_stratified = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# cvパラメータに渡す
scores = cross_val_score(
model, X, y,
cv=cv_stratified # StratifiedKFoldオブジェクトを指定
)
print(“Stratified K-Fold CVの結果:”)
print(f” 平均: {scores.mean():.4f} (±{scores.std():.4f})”)
💡 いつStratified K-Foldを使うべきか
分類問題では常にStratified K-Foldを使うことを推奨します。
🔬 5. 特殊な交差検証
Leave-One-Out CV（LOOCV）
Leave-One-Out CVとは：
データがN個 あるとき、1個をテスト、残りN-1個を訓練 として、これをN回繰り返す方法です。
# Leave-One-Out CV
from sklearn.model_selection import LeaveOneOut, cross_val_score
# 小さなデータセット（20件）を作成
X_small = X[:20]
y_small = y[:20]
# Leave-One-Out CVを作成
loo = LeaveOneOut()
# 交差検証を実行
model = LogisticRegression(max_iter=1000)
scores = cross_val_score(model, X_small, y_small, cv=loo)
print(“Leave-One-Out CVの結果:”)
print(f” 評価回数: {len(scores)}回”) # データ数と同じ
print(f” 平均スコア: {scores.mean():.4f}”)
print(f” 標準偏差: {scores.std():.4f}”)
Leave-One-Out CVの結果:
評価回数: 20回
平均スコア: 1.0000
標準偏差: 0.0000
時系列データ用のCV（TimeSeriesSplit）
時系列データでは通常のK-Foldは使えません。
理由：未来のデータで訓練して過去を予測してしまう（データリーク）
# 時系列用の交差検証
from sklearn.model_selection import TimeSeriesSplit
# TimeSeriesSplitを作成
tscv = TimeSeriesSplit(n_splits=5)
# 分割の様子を確認（インデックスで表示）
print(“TimeSeriesSplitの分割（時系列順序を維持）:”)
for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
print(f” Fold {fold+1}:”)
print(f” 訓練: インデックス {train_idx[0]}〜{train_idx[-1]} ({len(train_idx)}件)”)
print(f” テスト: インデックス {test_idx[0]}〜{test_idx[-1]} ({len(test_idx)}件)”)
TimeSeriesSplitの分割（時系列順序を維持）:
Fold 1:
訓練: インデックス 0〜24 (25件)
テスト: インデックス 25〜49 (25件)
Fold 2:
訓練: インデックス 0〜49 (50件)
テスト: インデックス 50〜74 (25件)
Fold 3:
訓練: インデックス 0〜74 (75件)
テスト: インデックス 75〜99 (25件)
Fold 4:
訓練: インデックス 0〜99 (100件)
テスト: インデックス 100〜124 (25件)
Fold 5:
訓練: インデックス 0〜124 (125件)
テスト: インデックス 125〜149 (25件)
✅ TimeSeriesSplitのポイント
・訓練データは常にテストデータより前 の期間増えていく
📊 6. 実践：モデル比較に交差検証を使う
交差検証の最も重要な使い方は、複数のモデルを公平に比較する ことです。
# 複数のモデルを交差検証で比較
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score, StratifiedKFold
# データ
iris = load_iris()
X, y = iris.data, iris.target
# 比較するモデルを辞書で定義
models = {
‘ロジスティック回帰’: LogisticRegression(max_iter=1000),
‘決定木’: DecisionTreeClassifier(random_state=42),
‘ランダムフォレスト’: RandomForestClassifier(n_estimators=100, random_state=42),
‘SVM’: SVC(kernel=’rbf’, random_state=42)
}
# 交差検証の設定
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# 各モデルを評価
print(“=”*50)
print(“モデル比較（5-Fold Stratified CV）”)
print(“=”*50)
results = {}
for name, model in models.items():
# 交差検証を実行
scores = cross_val_score(model, X, y, cv=cv, scoring=’accuracy’)
results[name] = scores
# 結果を表示
print(f”\n{name}:”)
print(f” 各Foldのスコア: {scores.round(4)}”)
print(f” 平均: {scores.mean():.4f} (±{scores.std():.4f})”)
==================================================
モデル比較（5-Fold Stratified CV）
==================================================
ロジスティック回帰:
各Foldのスコア: [0.9667 1. 0.9333 0.9667 1. ]
平均: 0.9733 (±0.0249)
決定木:
各Foldのスコア: [0.9667 0.9667 0.9333 0.9333 1. ]
平均: 0.9600 (±0.0249)
ランダムフォレスト:
各Foldのスコア: [0.9667 0.9667 0.9333 0.9333 1. ]
平均: 0.9600 (±0.0249)
SVM:
各Foldのスコア: [0.9667 1. 0.9667 0.9667 1. ]
平均: 0.9800 (±0.0163)
✅ 結果の解釈
SVM が最も高いスコア（98.00%）で、標準偏差も最も小さい（安定）ロジスティック回帰 も97.33%と高性能決定木とランダムフォレスト は同等の性能（96.00%）
📝 練習問題
問題1
やさしい
交差検証の目的
交差検証を行う主な目的として最も適切 なものを選んでください。
A. モデルの訓練を速くするため
B. より安定した信頼性の高い評価を得るため
C. データを増やすため
解答を見る
正解：B
交差検証は、データの分割方法に依存しない、安定した評価を得るための手法です。全データを訓練にも評価にも使うことで、1回の分割では得られない信頼性の高い性能推定ができます。
問題2
やさしい
K-Fold CVの理解
5-Fold CVでは、各foldでデータの何%が訓練に使われますか？
解答を見る
正解：C（80%）
5-Fold CVでは、データを5等分して1つをテスト、残り4つを訓練に使います。4/5 = 80%が訓練データです。
問題3
やさしい
Stratified K-Foldの特徴
Stratified K-Foldが通常のK-Foldと異なる点は何ですか？
A. データをシャッフルする
B. 各foldでクラスの比率を維持する
C. 訓練データが多くなる
解答を見る
正解：B
Stratified K-Foldは、元データのクラス比率を各foldで維持します。これにより、不均衡データでも公平な評価ができます。
問題4
ふつう
cross_val_scoreの使い方
以下のコードの空欄を埋めてください。
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier()
scores = cross_val_score(model, X, y, cv=___, scoring=’___’)
解答を見る
# cv: 分割数を指定（5や10が一般的）
# scoring: 評価指標を指定（分類なら’accuracy’など）
scores = cross_val_score(model, X, y, cv=5, scoring=’accuracy’)
問題5
ふつう
回帰問題での評価指標
回帰問題でRMSEを使って交差検証する場合、scoring引数に何を指定しますか？
解答を見る
# RMSEの場合、負値を使う（neg_root_mean_squared_error）
scores = cross_val_score(model, X, y, cv=5, scoring=’neg_root_mean_squared_error’)
# 実際のRMSEを得るには、負号を取り除く
rmse_scores = -scores
print(f”RMSE: {rmse_scores.mean():.4f}”)
scikit-learnでは「スコアは大きいほど良い」というルールがあるため、誤差系の指標には「neg_」がつきます。
問題6
むずかしい
Leave-One-Out CVの実装
Leave-One-Out CVを使ってロジスティック回帰を評価するコードを書いてください。
解答を見る
from sklearn.model_selection import LeaveOneOut, cross_val_score
from sklearn.linear_model import LogisticRegression
# LeaveOneOutオブジェクトを作成
loo = LeaveOneOut()
# モデルを作成
model = LogisticRegression(max_iter=1000)
# 交差検証を実行
scores = cross_val_score(model, X, y, cv=loo)
# 結果を表示
print(f”評価回数: {len(scores)}”) # = データ数
print(f”平均スコア: {scores.mean():.4f}”)
問題7
むずかしい
時系列データのCV
時系列データに通常のK-Foldを使ってはいけない理由を説明し、代わりに何を使うべきか答えてください。
解答を見る
理由： 通常のK-Foldはデータをランダムに分割するため、「未来のデータで訓練して過去を予測する」という現実にはありえない状況が発生します（データリーク）。
代替手法： TimeSeriesSplitを使います。
from sklearn.model_selection import TimeSeriesSplit, cross_val_score
# TimeSeriesSplitは常に「過去→未来」の順序を維持
tscv = TimeSeriesSplit(n_splits=5)
scores = cross_val_score(model, X, y, cv=tscv)
問題8
むずかしい
複数モデルの比較
決定木とランダムフォレストを5-Fold Stratified CVで比較するコードを書いてください。
解答を見る
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score, StratifiedKFold
# 交差検証の設定
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# 決定木
dt = DecisionTreeClassifier(random_state=42)
scores_dt = cross_val_score(dt, X, y, cv=cv)
# ランダムフォレスト
rf = RandomForestClassifier(n_estimators=100, random_state=42)
scores_rf = cross_val_score(rf, X, y, cv=cv)
# 比較
print(f”決定木: {scores_dt.mean():.4f} (±{scores_dt.std():.4f})”)
print(f”RF: {scores_rf.mean():.4f} (±{scores_rf.std():.4f})”)
📝 STEP 22 のまとめ
✅ このステップで学んだこと
交差検証の必要性： ホールドアウト法の限界を克服し、安定した評価を得るK-Fold CV： データをK分割し、各foldを順番にテストに使用cross_val_score： 1行で交差検証を実行できる便利な関数Stratified K-Fold： クラス比率を維持する層化交差検証（分類問題で推奨）Leave-One-Out： データが少ない場合に有効TimeSeriesSplit： 時系列データ用の交差検証
🚀 次のステップへ
次のSTEP 23では、バイアス-バリアンストレードオフと過学習 を学びます。モデルが「過学習」しているかどうかを診断する方法を習得しましょう！
❓ よくある質問
Q1. Kの値はいくつが良いですか？
一般的にはK=5またはK=10 が推奨されます。K=5は計算が速く、K=10はより安定した評価が得られます。データが少ない場合はK=10、データが多い場合はK=5で十分です。
Q2. shuffleはTrueにすべきですか？
通常はTrue にします。データが何らかの順序で並んでいる場合（例：最初が正常、後半が異常）、シャッフルしないと各foldの性質が偏ってしまいます。ただし、時系列データの場合はFalse （またはTimeSeriesSplitを使用）にします。
Q3. 交差検証後、最終モデルはどうやって作りますか？
交差検証はあくまで性能の推定 のためです。最終モデルは、全データを使って再度訓練 します。交差検証で得たスコアが、その最終モデルの期待される性能です。
Q4. 交差検証の結果が毎回違うのはなぜ？
random_stateを固定していない場合、シャッフルの結果が毎回変わるためです。再現性が必要な場合は、必ずrandom_state=42のように固定値を設定してください。
Q5. cross_val_scoreとcross_validateの違いは？
cross_val_scoreはスコアのみを返します。cross_validateは、スコアに加えて訓練時間、テスト時間、訓練スコアなども返します。より詳細な情報が必要な場合はcross_validateを使います。
×
artnasekai
#artnasekai #学習メモ
