11. scikit-learnで未来を予測するモデルを作ろう

第1章：はじめに

この章では、本格的なプログラミング学習に入る前に、私たちがこれから学ぼうとしている「機械学習」と、そのための強力なツール「Scikit-learn」がどのようなものなのか、全体像を掴んでいきましょう。

1-1. 機械学習とは？

最近、「AI（人工知能）」という言葉をニュースや日常会話でよく耳にするようになりました。機械学習は、そのAIを実現するための中心的な技術の一つです。

AI・機械学習・ディープラーニングの違い

これら3つの言葉はよく混同されますが、以下のような関係性を持っています。

AI (人工知能): 最も広い概念です。人間の知的な振る舞いをコンピュータで模倣しようとする技術や学問分野全体を指します。
機械学習 (Machine Learning): AIを実現するための一つの「手法」です。コンピュータに大量のデータを与え、データに潜むパターンやルールを自動的に学習させ、それに基づいて予測や判断を行わせる技術です。
ディープラーニング (Deep Learning): 機械学習の中の、さらに特定の手法（主にニューラルネットワーク）を指します。特に複雑なパターン認識（画像認識や自然言語処理など）で高い性能を発揮します。

本書で扱うScikit-learnは、この中の「機械学習」を実装するためのライブラリ（便利な道具箱）です。

機械学習でできること

機械学習は、大きく分けて以下の3つのタスクが得意です。本書でも、これらのタスクを順番に体験していきます。

分類 (Classification)
- 目的: データをあらかじめ決められたグループ（カテゴリ）に分ける。
- 例:
  - メールが「スパム」か「迷惑メールでない」か判断する。
  - 画像に写っている動物が「犬」か「猫」か見分ける。
  - 顧客が「購入する」か「購入しない」か予測する。
回帰 (Regression)
- 目的: あるデータ（数値）に基づいて、別の連続した数値（結果）を予測する。
- 例:
  - 家の「広さ」や「駅からの距離」から、「家賃」を予測する。
  - 過去の「気温」データから、明日の「アイスクリームの売上」を予測する。
クラスタリング (Clustering)
- 目的: 正解（グループ分け）が与えられていないデータ群から、似たもの同士の集まり（クラスター）を自動的に見つけ出す。
- 例:
  - 顧客の購買履歴から、似た傾向を持つ「顧客グループ」に分ける。
  - ニュース記事を内容ごとに「スポーツ」「政治」「経済」などのトピックに自動分類する。

1-2. Scikit-learnとは？

Scikit-learn (サイキット・ラーン) は、Pythonで機械学習を実装するために最も広く使われている、オープンソースのライブラリです。

Scikit-learnの特徴と立ち位置

Scikit-learnは、Pythonの科学技術計算エコシステム（通称: SciPyスタック）の中核をなすライブラリです。

NumPy: 高速な数値計算（行列や多次元配列）を行うライブラリ。Scikit-learnの土台となっています。
Pandas: Excelの表のような、行と列を持つデータ（データフレーム）を柔軟に操作するためのライブラリ。データの前処理で活躍します。
Matplotlib: データをグラフや図で可視化するためのライブラリ。
Scikit-learn: これらライブラリとシームレスに連携し、機械学習アルゴリズムの実行を担当します。

なぜScikit-learnが選ばれるのか

世界中のデータサイエンティストやエンジニアがScikit-learnを選ぶのには、明確な理由があります。

使いやすい統一されたインターフェース:これが最大の強みです。k-NN法、線形回帰、K-Means法など、全く異なるアルゴリズムでも、fit() (学習) や predict() (予測) といったほぼ同じ命令（メソッド）で操作できます。これにより、初学者はアルゴリズムごとの細かい文法を覚える必要がなく、非常に学習しやすい設計になっています。
豊富なアルゴリズム:前述した「分類」「回帰」「クラスタリング」のための代表的なアルゴリズムが、ほぼすべて網羅されています。
充実したドキュメントとコミュニティ:公式ドキュメントが非常に充実しており、使い方の例（サンプルコード）も豊富です。また、利用者が多いため、エラーや疑問点があってもインターネットで検索すれば大抵の答えが見つかります。
商用利用も可能なライセンス (BSD):学術研究だけでなく、ビジネスの現場でも安心して利用できます。

注意点: Scikit-learnは「機械学習」のためのライブラリです。ディープラーニング（深層学習）は専門外であり、そちらはTensorFlowやPyTorchといった別のライブラリが主流となります。

1-3. 本書の進め方と学習のゴール

本書は、プログラミングやデータ分析の経験が浅い方でも、機械学習の基本的な流れを「手を動かしながら」学べるように構成されています。

本書の進め方:

環境構築 (第2章):まず、学習の拠点となるVSCode（Visual Studio Code）に必要なツール（PythonやScikit-learn）をインストールします。
基本操作 (第3章):Scikit-learnの基本的な「お作法」（データの扱い方や命令の方法）を学びます。
代表的なアルゴリズムの実践 (第4〜6章):「分類」「回帰」「クラスタリング」の3つのタスクを、それぞれ代表的なアルゴリズムを使って実際に解いてみます。
実践的なテクニック (第7〜8章):現実のデータ（汚れたデータ）を扱うための「前処理」や、モデルの精度を高めるための「チューニング」といった、より実践的なテクニックを学びます。

本書の学習ゴール:

本書を終える頃には、あなたは以下の状態になっているはずです。

VSCodeを使って、Pythonでデータ分析を行う環境を自分で構築できる。
機械学習の基本的なワークフロー（データの準備 → 学習 → 評価）を説明し、実装できる。
Scikit-learnを使い、基本的な「分類」「回帰」「クラスタリング」の問題を解くコードが書ける。
公式ドキュメントやWeb上の情報を参照しながら、新しいアルゴリズムにも挑戦できる力が身についている。

難しく感じるかもしれませんが、VSCodeの便利な機能を使いながら、一つずつコードを実行して結果を確かめていけば、必ず理解できます。さっそく次の章で、学習環境を整えるところから始めましょう！

第2章：VSCodeによる開発環境構築 🚀

機械学習を学ぶ旅に出る前に、まずは道具を揃えましょう。この章では、学習の拠点となる「VSCode (Visual Studio Code)」をセットアップし、PythonとScikit-learnを使える状態にします。

2-1. なぜVSCodeなのか？

VSCodeは、Microsoftが開発した無料のコードエディタです。世界中の開発者に人気ですが、特にデータサイエンスの分野で急速に支持を集めています。

データサイエンスにおけるVSCodeの強み:

Jupyter Notebookの統合: データ分析で定番の「Jupyter Notebook」を、VSCode内で直接（しかも快適に）操作できます。
高機能なコード補完 (IntelliSense): ライブラリの関数名や引数を忘れがちな初学者を強力にサポートします。
デバッグ機能: コードがうまく動かない時、一行ずつ実行しながら変数の中身を確認できます。
豊富な拡張機能: Pythonだけでなく、あらゆるプログラミング言語に対応できるカスタマイズ性が魅力です。

本書では、このVSCodeの「Jupyter Notebook機能」をメインに使って学習を進めます。

2-2. 必要なツールのインストール

Pythonのインストール

Scikit-learnはPythonのライブラリなので、大元のPythonが必要です。

Python公式サイト (python.org) にアクセスします。
「Downloads」ページから、最新の安定版（例: Python 3.11.x）をダウンロードします。
インストーラーを起動したら、非常に重要なチェックボックスがあります。
- 「Add Python 3.x to PATH」（または「Add python.exe to Path」）に必ずチェックを入れてください。
- これにチェックを入れると、コンピュータのどこからでもPythonを呼び出せるようになります。
「Install Now」をクリックしてインストールを完了します。

VSCodeのインストールと日本語化

VSCode公式サイト (code.visualstudio.com) にアクセスします。
お使いのOS（Windows, Mac, Linux）に合ったインストーラーをダウンロードし、画面の指示に従ってインストールします。
VSCodeを起動すると、最初は英語表示になっています。
左側のアクティビティバー（アイコンが縦に並んだ場所）から、四角いブロックのような「拡張機能 (Extensions)」アイコンをクリックします。
検索ボックスに「Japanese Language Pack」と入力します。
出てきた拡張機能を「Install」し、VSCodeを再起動するとUIが日本語化されます。

2-3. VSCodeのセットアップ

次に、VSCodeでPythonとJupyter Notebookを使えるようにします。

必須の拡張機能

先ほどと同じ「拡張機能」タブで、以下の2つを検索してインストールします。

Python (Microsoft製):
- これが無いと始まりません。コード補完、デバッグ、Jupyterのサポートなど、Python開発に必要な機能がすべて詰まっています。
Jupyter (Microsoft製):
- VSCode内で .ipynb ファイル（Jupyter Notebook）を動かすために必要です。

Pythonインタープリターの選択

PCに複数のPythonバージョンがインストールされている場合、VSCodeに「どのPythonを使うか」を教える必要があります。

VSCodeで Ctrl + Shift + P (Macなら Cmd + Shift + P) を押して、コマンドパレットを開きます。
Python: Select Interpreter (または Python: インタープリターを選択) と入力し、選択します。
リストが表示されるので、先ほどインストールしたPythonのバージョン（例: Python 3.11.x）を選びます。

2-4. 仮想環境の構築 (venv)

これは初学者にとって最初の関門かもしれませんが、非常に重要な習慣です。

なぜ仮想環境が必要なのか？

プロジェクトごとに「専用の道具箱（環境）」を作るためです。

例えば、プロジェクトAでは「Scikit-learn バージョン1.0」を使い、プロジェクトBでは「バージョン1.2」を使いたい場合、コンピュータ全体（グローバル環境）にインストールしてしまうと競合が起きます。

仮想環境を使うと、「Scikit-learn学習用フォルダ」の中だけで有効なPython環境を作れるため、他のプロジェクトやPC本体を汚さずに済みます。

VSCodeターミナルでの仮想環境作成

VSCodeで「ファイル」>「フォルダーを開く...」を選び、このテキスト学習用の新しいフォルダ（例: sklearn-study）を作成し、それを開きます。
VSCodeで Ctrl + @ (Macなら Cmd + J) を押して、VSCodeの下部にターミナルを開きます。
ターミナルに以下のコマンドを入力し、実行します。（venv という名前の仮想環境フォルダが作られます）

# Windows
python -m venv venv

# Mac / Linux
python3 -m venv venv

次に、その仮想環境を「有効化」します。

# Windows (PowerShell)
.\venv\Scripts\Activate.ps1

# Mac / Linux
source venv/bin/activate

ターミナルのプロンプト（行の先頭）に (venv) と表示されれば成功です。この状態が「専用の道具箱に入った状態」です。

（VSCodeが「新しい仮想環境を検出しました。使用しますか？」と聞いてきたら「はい」を選んでください。）

2-5. Scikit-learnと関連ライブラリのインストール

仮想環境が有効化されたターミナル (venv) で、いよいよScikit-learnと、データ分析に必要な仲間たち（Pandas, NumPy, Matplotlib, Jupyter）をインストールします。

以下のコマンドをターミナルにコピー＆ペーストして実行してください。

pip install scikit-learn numpy pandas matplotlib jupyter

pip はPythonのパッケージ管理ツールです。
これにより、venv という道具箱の中に、必要なライブラリがすべてインストールされます。

2-6. VSCodeでの実行方法

これで準備は万端です。VSCodeでコードを実行する主な方法を2つ紹介します。

Jupyter Notebook (.ipynb) の使い方

本書では主にこちらを使います。コードをセル単位で実行し、結果（数値やグラフ）をその場ですぐに確認できるため、データ分析に最適です。

VSCodeのエクスプローラー（左上のファイルアイコン）で、新しいファイルを作成します。名前を「test.ipynb」のように、末尾を .ipynb にします。
ファイルを開くと、Jupyter Notebookの画面が表示されます。
コードセルに print("Hello Scikit-learn!") と入力します。
セルの左側にある「実行 (▶)」ボタンを押します。
初回実行時、VSCodeが「カーネル（実行環境）の選択」を求めてきます。必ず、先ほど作成した仮想環境（venv 内のPython）を選択してください。
セルの下に Hello Scikit-learn! と表示されれば成功です。

Pythonスクリプト (.py) のインタラクティブ実行

Jupyter Notebookではなく、通常のPythonファイル (.py) でも、VSCodeなら対話的に実行できます。

「test.py」というファイルを作成します。
ファイルに import sklearn と print(sklearn.__version__) と書きます。
ファイル全体ではなく、実行したい行（2行）を選択します。
Shift + Enter を押します。
VSCodeが「Pythonインタラクティブ」ウィンドウを自動で開き、選択したコードだけを実行してくれます。
Scikit-learnのバージョン番号（例: 1.4.0）が表示されれば成功です。

お疲れ様でした！これで、Scikit-learnを使った機械学習をVSCodeで学ぶ準備がすべて整いました。

次の章から、いよいよ機械学習の基本的な考え方とScikit-learnの操作方法に入っていきます。

第3章：機械学習の基本とScikit-learnの作法

環境構築が完了したところで、いよいよ機械学習の世界に入ります。この章では、機械学習プロジェクトの一般的な「流れ」と、Scikit-learnを操作する上で最も重要な「共通ルール（お作法）」を学びます。

ここを理解すれば、今後さまざまなアルゴリズムを驚くほどスムーズに使いこなせるようになります。

3-1. 機械学習の基本的な流れ

どんな機械学習プロジェクトでも、大まかな流れは共通しています。料理に例えるなら、レシピのようなものです。

問題設定とデータ収集:
- （何をしたいのか？ → 例: アヤメの種類を分類したい）
- （そのために必要なデータは？ → 例: 花びらの長さや幅のデータ）
データの前処理 (Data Preprocessing):
- 収集したデータを機械が読み込める形に整えます。（例: 空欄のデータを埋める、文字を数値に変換する）
- 現実のプロジェクトでは、作業時間の約8割がこの前処理と言われるほど重要です。
データの分割:
- 持っているデータを「学習用データ（教科書・問題集）」と「テスト用データ（本番の試験）」に分けます。
- ※カンニング（学習用データで答え合わせ）を防ぐためです。
モデルの選択と学習:
- 問題（分類、回帰など）に合ったアルゴリズム（モデル）を選びます。
- 「学習用データ」をモデルに与えて、パターンを学ばせます（これを fit と呼びます）。
モデルの評価:
- 学習に使っていない「テスト用データ」でモデルの実力を試します。
- （例: このモデルの正解率は95%だ）
予測 (推論):
- 実力を認められたモデルを使い、未来の新しいデータ（答えが未知のもの）を予測させます。

Scikit-learnは、主にこの「3〜6」のステップを強力にサポートしてくれます。

3-2. Scikit-learnの重要概念

Scikit-learnでデータを扱う際、データは特定の形式（主にNumPy配列やPandasのDataFrame）で用意する必要があります。そして、データを2種類に分けて呼びます。

特徴量 (Feature):
- 予測を行うための「原因」や「説明」となるデータ。
- 通常、アルファベットの大文字 X で表されます。
- （例: アヤメの「がくの長さ」「花びらの幅」、家の「広さ」「駅からの距離」）
ターゲット (Target / Label):
- 予測したい「結果」や「答え」。
- 通常、アルファベットの小文字 y で表されます。
- （例: アヤメの「種類名」、家の「価格」）

機械学習とは、「X（特徴量）から y（ターゲット）を予測するルールを学ぶこと」と言い換えることができます。

3-3. Scikit-learnの基本API（統一された操作方法）

Scikit-learnの最大の強みは、どんなアルゴリズムでも操作方法が統一されていることです。この「お作法」さえ覚えれば、新しいアルゴリズムもすぐに試せます。

1. Estimator (推定量) オブジェクト

Scikit-learnでは、機械学習のアルゴリズム（モデル）のことを Estimator (エスティメータ) と呼びます。

まずは、使いたいアルゴリズムを「インポート（道具箱から取り出す）」し、その「インスタンス（実体）」を作ります。

# VSCodeの .ipynb ファイルで実行してみましょう

# 1. 使いたいアルゴリズムをインポートする
from sklearn.neighbors import KNeighborsClassifier

# 2. アルゴリズムのインスタンス（実体）を作る
# (n_neighbors=3) は「近くの3軒のデータを見て判断してね」という設定（ハイパーパラメータ）
model = KNeighborsClassifier(n_neighbors=3)

2. `fit()` メソッド：モデルの学習

fit は「適合させる」という意味です。学習用データ（X_train, y_train）を与えて、モデルにルールを学ばせます。

# ※ このコードはまだ実行できません。X_train, y_train は次のセクションで作ります
# 3. 学習用データ (X_train) とその答え (y_train) を使って学習させる
model.fit(X_train, y_train)

model.fit(X, y) という形は、Scikit-learn全体で共通の「学習」コマンドです。

3. `predict()` メソッド：未知のデータの予測

学習が完了したモデルを使って、新しいデータ（X_test）に対する予測を行います。

# ※ このコードもまだ実行できません
# 4. 学習に使っていないテストデータ (X_test) を使って予測させる
predictions = model.predict(X_test)

model.predict(X) も共通の「予測」コマンドです。

4. `transform()` メソッド：データの前処理 (第7章で詳述)

前処理（スケーリングや欠損値補完など）を行うEstimatorには、predict の代わりに transform が用意されています。これはデータを「変換」するためのコマンドです。

まとめ (Scikit-learnの3ステップ):

モデルを選ぶ: model = AlgorithmName()

学習させる: model.fit(X_train, y_train)

予測させる: model.predict(X_test)

3-4. Scikit-learnに付属するデータセット

Scikit-learnには、学習用にいくつかの有名なデータセットが最初から含まれています。今回は、機械学習の「Hello, World!」とも言えるIris (アヤメ) データセットを使ってみましょう。

これは、3種類のアヤメ（Setosa, Versicolor, Virginica）について、4つの特徴量（がくの長さ/幅、花びらの長さ/幅）を測定したデータです。

VSCodeで practice.ipynb などのファイルを開き、以下のコードをセルに入力して実行してみましょう。

# 1. 必要なライブラリをインポート
from sklearn.datasets import load_iris
import pandas as pd

# 2. Irisデータセットをロード（読み込み）
iris = load_iris()

# 3. データの中身を確認
# irisデータは特別な形式（Bunchオブジェクト）なので、中身を見てみます
print(iris.keys())
# dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module'])

iris オブジェクトには、データに関する様々な情報が辞書型で格納されています。

iris.data: これが 特徴量 X（4つの測定値）です。
iris.target: これが ターゲット y（アヤメの種類が0, 1, 2の数値で入っている）です。
iris.feature_names: 特徴量 X の各列の名前（'sepal length (cm)'など）です。
iris.target_names: ターゲット y の数値（0, 1, 2）が実際には何の種類を指すか（'setosa'など）です。

Pandasで表として見やすく表示する

このままでは見づらいので、PandasのDataFrameに変換して表示してみましょう。これがデータ分析の定石です。

# 特徴量 X をDataFrameに変換
# カラム名（列名）には feature_names を指定
X = pd.DataFrame(iris.data, columns=iris.feature_names)

# ターゲット y をDataFrame（Series）に追加
y = pd.Series(iris.target)

# データを表示
print("--- 特徴量 X (最初の5行) ---")
print(X.head())

print("\n--- ターゲット y (最初の5行) ---")
print(y.head())

# ターゲット 0 が何を表すか確認
print("\n--- ターゲットの名前 ---")
print(iris.target_names) # [0: 'setosa', 1: 'versicolor', 2: 'virginica']

実行結果 (X.head()):

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                5.1               3.5                1.4               0.2
1                4.9               3.0                1.4               0.2
2                4.7               3.2                1.3               0.2
3                4.6               3.1                1.5               0.2
4                5.0               3.6                1.4               0.2

実行結果 (y.head()):

0    0
1    0
2    0
3    0
4    0
dtype: int64

（最初の5行はすべてターゲット「0」、つまり 'setosa' であることが分かりました）

お疲れ様でした！

これでScikit-learnの「お作法」と、扱うデータの「X と y」という形が理解できました。

次の章では、このIrisデータセットを使い、Scikit-learnの3ステップ（model選択, fit, predict）に従って、実際に「分類」タスクに挑戦します。

第4章：【実践】最初の機械学習：分類 (Classification)

お待たせしました！いよいよ、Scikit-learnを使って最初の機械学習モデルを構築します。この章では、最も直感的で基本的なタスクである「分類 (Classification)」に挑戦します。

第3章で準備した「Iris (アヤメ) データセット」を使い、「花びらの測定値（特徴量 X）から、アヤメの種類（ターゲット y）を予測する」モデルを作っていきましょう。

4-1. 分類とは？

分類とは、データをあらかじめ決められた「カテゴリ（グループ）」のどれかに振り分けるタスクです。

例1: メールが「スパム」か「スパムでない」か。 (2値分類)
例2: 手書きの数字画像が「0」〜「9」のどれか。 (多クラス分類)
今回のタスク: アヤメが「Setosa」「Versicolor」「Virginica」のどれか。(多クラス分類)

4-2. データの準備

まずは、第3章のおさらいです。VSCodeでJupyter Notebook (.ipynb) を開き、データを準備します。

# 1. 必要なライブラリをインポート
from sklearn.datasets import load_iris
import pandas as pd

# 2. Irisデータセットをロード
iris = load_iris()

# 3. 特徴量 X と ターゲット y に分ける
# .data が X, .target が y に相当する
X = iris.data
y = iris.target

# 4. （確認用）データの形状を見てみる
# (150, 4) は「150行（サンプル）、4列（特徴量）」
# (150,) は「150行（サンプル）」
print(f"特徴量 X の形状: {X.shape}")
print(f"ターゲット y の形状: {y.shape}")

実行結果:

特徴量 X の形状: (150, 4)
ターゲット y の形状: (150,)

これで、150個のアヤメのデータ（特徴量 X 4種類、ターゲット y 1種類）が用意できました。

4-3. データの分割 (train_test_split)

第3章で学んだように、機械学習ではデータを「学習用」と「テスト用」に分ける必要があります。これは、モデルが学習データだけを丸暗記（過学習 といいます）していないか、未知の問題（テストデータ）で実力を測るためです。

Scikit-learnには、この分割を簡単に行うための train_test_split という便利な関数が用意されています。

# 1. train_test_split をインポート
from sklearn.model_selection import train_test_split

# 2. データを分割
# test_size=0.3: 全体の30%をテスト用にする（70%が学習用）
# random_state=0: 毎回同じように分割するための「乱数の種」。0でなくても良いが、固定すると結果を再現できる。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# 3. （確認用）それぞれの形状を見てみる
print(f"X_train (学習用の特徴量): {X_train.shape}") # 150 * 0.7 = 105
print(f"X_test (テスト用の特徴量): {X_test.shape}")   # 150 * 0.3 = 45
print(f"y_train (学習用の答え): {y_train.shape}")
print(f"y_test (テスト用の答え): {y_test.shape}")

実行結果:

X_train (学習用の特徴量): (105, 4)
X_test (テスト用の特徴量): (45, 4)
y_train (学習用の答え): (105,)
y_test (テスト用の答え): (45,)

これで、X_train（問題集）、y_train（問題集の答え）、X_test（試験問題）、y_test（試験の解答）が揃いました。

4-4. モデルの選択と学習 (fit)

いよいよモデルを選びます。今回は、分類タスクで最もシンプルで直感的なアルゴリズムの一つ「k-近傍法 (k-Nearest Neighbors, k-NN)」を使います。

アルゴリズム紹介：k-近傍法 (k-NN)

k-NNは「ご近所さん（k個の最も近いデータ）の多数決で決める」という、非常にシンプルなアルゴリズムです。

k=1 なら、一番近いデータと同じカテゴリに分類します。
k=3 なら、最も近い3つのデータを見て、一番多いカテゴリに分類します。

それでは、Scikit-learnの「お作法」3ステップ（選択、fit、predict）に従って実装します。

# 1. 使いたいアルゴリズム（モデル）をインポート
from sklearn.neighbors import KNeighborsClassifier

# 2. モデルのインスタンス（実体）を作成
# ここで k を決める (n_neighbors=3 は k=3 の意味)
model = KNeighborsClassifier(n_neighbors=3)

# 3. モデルを「学習」させる
# 学習用データ (X_train, y_train) を使って、ルールを学ばせる
model.fit(X_train, y_train)

print("モデルの学習が完了しました！")

実行結果:

モデルの学習が完了しました！

たったこれだけです。model.fit() を実行した時点で、モデルは105個の学習データを「覚えた」状態になりました。

4-5. 予測と評価 (predict)

学習したモデルがどれほど賢くなったか、実力を試します。fit には使っていない「テスト用データ (X_test)」を使って予測（predict）させ、本当の答え（y_test）と見比べます。

# 1. テストデータ (X_test) を使って「予測」を実行
# モデルは X_test の答え (y_test) を知らない
y_pred = model.predict(X_test)

# 2. 予測結果 (y_pred) と 正解 (y_test) を見比べてみる
print(f"予測結果 (y_pred): {y_pred}")
print(f"実際の正解 (y_test): {y_test}")

実行結果:

予測結果 (y_pred): [2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0 1 1 1 2 0 2 1 2]
実際の正解 (y_test): [2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0 2 1 1 2 0 2 1 2]

パッと見たところ、ほとんど一致しているようです。

正解率 (Accuracy) の計算

「だいたい合ってる」では不十分なので、accuracy_score を使って「正解率」を計算します。

# 1. accuracy_score をインポート
from sklearn.metrics import accuracy_score

# 2. 正解率を計算
accuracy = accuracy_score(y_test, y_pred)

print(f"モデルの正解率 (Accuracy): {accuracy * 100:.2f} %")

実行結果:

モデルの正解率 (Accuracy): 97.78 %

素晴らしい結果が出ました！私たちが作ったモデルは、初めて見る45問のテストデータに対して、約97.8%の正解率でアヤメの種類を分類できたことになります。

（コラム）混同行列 (Confusion Matrix)

正解率だけでは「どこを間違えたか」が分かりません。それを可視化するのが混同行列です。

行：実際の正解 (y_test)
列：モデルの予測 (y_pred)
対角線：正しく分類できた数
対角線以外：間違えた数

from sklearn.metrics import confusion_matrix
import seaborn as sns # 可視化ライブラリ
import matplotlib.pyplot as plt # 可視化ライブラリ

# 1. 混同行列を計算
cm = confusion_matrix(y_test, y_pred)
print("混同行列:\n", cm)

# 2. （参考）ヒートマップで可視化
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
            xticklabels=iris.target_names, 
            yticklabels=iris.target_names)
plt.xlabel('Predicted (予測)')
plt.ylabel('Actual (実際)')
plt.show() # VSCodeのJupyterならセル下にグラフが表示される

実行結果:

混同行列:
 [[16  0  0]
  [ 0 17  1]
  [ 0  0 11]]

行列の見方:

[0, 0] (左上) : 16個の 'setosa' (0) を、正しく 'setosa' (0) と予測。
[1, 1] (中央) : 17個の 'versicolor' (1) を、正しく 'versicolor' (1) と予測。
[2, 2] (右下) : 11個の 'virginica' (2) を、正しく 'virginica' (2) と予測。
[1, 2] (中央右) : 1個だけ 'versicolor' (1) を、間違えて 'virginica' (2) と予測してしまった。

45問中、間違いは1問だけだったことが一目でわかります。

4-6. VSCodeのJupyterで結果を可視化する

最後に、k=3 のモデルがどのようにデータを「分類している（しようとしている）」のか、Matplotlibを使ってグラフにしてみましょう。

（特徴量は4つ (Xは4次元) あるため、そのままでは可視化できません。ここでは、分析でよく使われる「花びらの長さ (Xの2列目)」と「花びらの幅 (Xの3列目)」の2つだけを使って、簡易的に学習・可視化します。）

import numpy as np
import matplotlib.pyplot as plt

# 2つの特徴量（花びらの長さ・幅）のみを X_simple として使用
X_simple = iris.data[:, [2, 3]]
y_simple = iris.target

# k-NNモデル (k=3) を再度学習
model_simple = KNeighborsClassifier(n_neighbors=3)
model_simple.fit(X_simple, y_simple)

# --- ここから可視化コード ---
# (少し複雑ですが、結果を見るだけでも大丈夫です)

# グラフの背景（決定境界）を塗るための準備
x_min, x_max = X_simple[:, 0].min() - 0.5, X_simple[:, 0].max() + 0.5
y_min, y_max = X_simple[:, 1].min() - 0.5, X_simple[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))

# メッシュの各点に対する予測を実行
Z = model_simple.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# 背景をプロット
plt.figure(figsize=(10, 7))
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.coolwarm)

# 実際のデータ点（正解）をプロット
scatter = plt.scatter(X_simple[:, 0], X_simple[:, 1], c=y_simple, cmap=plt.cm.coolwarm, edgecolor='k')

# 凡例（はんれい）の追加
handles, labels = scatter.legend_elements()
plt.legend(handles, iris.target_names, title="Species")

plt.xlabel(iris.feature_names[2]) # petal length (cm)
plt.ylabel(iris.feature_names[3]) # petal width (cm)
plt.title("k-NN (k=3) Decision Boundaries on Iris Petal")
plt.show()

実行結果:

グラフの見方:

点: 実際のデータ（正解）
色の塗られた領域: モデルが「この範囲に来たら、この色（種類）と判断します」という決定境界（テリトリー）

このグラフから、k-NNモデルが3種類のアヤメを分類するために、複雑な「境界線」を引いていることがわかります。

お疲れ様でした！これで、データの準備から、分割、学習、予測、評価、そして可視化という、機械学習の基本的な流れをすべて体験することができました。

次の章では、もう一つの重要なタスク「回帰（Regression）」に挑戦します。

第5章：教師あり学習：回帰 (Regression) 📈

前の章では、データをカテゴリに分ける「分類」を学びました。この章では、教師あり学習のもう一つの柱である「回帰 (Regression)」を学びます。

5-1. 回帰とは？

回帰とは、あるデータ（特徴量 X）から、連続した数値（ターゲット y）を予測するタスクです。

分類 (Classification)
- 目的: カテゴリを当てる（例: "犬", "猫", "鳥"）
- 答え: 離散的な値（例: 0, 1, 2）
回帰 (Regression)
- 目的: 数値を予測する（例: "150万円", "23.5度"）
- 答え: 連続的な値（例: 150.0, 23.5）

今回のタスク例:

「その地域の様々な特徴（所得、築年数など）から、その地域の住宅価格を予測する」モデルを作ってみましょう。

5-2. データの準備 (California Housing)

今回は、Scikit-learn付属の「California住宅価格データセット」を使います。

（以前は「Boston住宅価格」が定番でしたが、データに含まれる倫理的な問題のため、現在はCaliforniaが推奨されています。）

VSCodeのJupyter Notebookで、まずはデータを読み込み、X と y に分けましょう。

# 1. 必要なライブラリをインポート
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
import pandas as pd

# 2. California住宅価格データセットをロード
# (as_frame=True にすると、PandasのDataFrame形式で直接読み込めて便利)
housing = fetch_california_housing(as_frame=True)

# 3. 特徴量 X と ターゲット y に分ける
X = housing.data       # .data に特徴量 (X) が入っている
y = housing.target     # .target にターゲット (y) が入っている (価格)

# 4. （確認用）データの中身と形状を見てみる
print("--- 特徴量 X (最初の5行) ---")
print(X.head())

print("\n--- ターゲット y (価格) (最初の5行) ---")
print(y.head())

print(f"\n特徴量 X の形状: {X.shape}") # (20640, 8) 2万件のデータ、8種類の特徴量
print(f"ターゲット y の形状: {y.shape}")

実行結果 (X.head()):

   MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup  Latitude  Longitude
0  8.3252      41.0  6.984127   1.023810       322.0  2.555556     37.88    -122.23
1  8.3014      21.0  6.238137   0.971880      2401.0  2.109842     37.86    -122.22
2  7.2574      52.0  8.288136   1.073446       496.0  2.802260     37.85    -122.24
3  5.6431      52.0  5.817352   1.073059       558.0  2.547945     37.85    -122.25
4  3.8462      52.0  6.281853   1.081081       565.0  2.181467     37.85    -122.25

MedInc: 所得の中央値
HouseAge: 築年数の中央値
...など、8つの特徴から y (価格) を予測します。

5-3. データの分割とスケーリング

第4章と同様に、データを学習用とテスト用に分割します。

さらに、今回は「スケーリング（標準化）」という重要な前処理も行います。

なぜスケーリングが必要？

X の中身を見ると、「所得(MedInc)」は 8.3、「人口(Population)」は 322.0 と、数値のスケール（単位の大きさ）が全く違います。

多くの機械学習アルゴリズム（特に線形回帰）は、数値のスケールが違いすぎると、値が大きい特徴量（=人口）だけを過度に重視してしまい、うまく学習できません。

そこで StandardScaler を使い、すべての特徴量を平均0、標準偏差1の「同じ土俵」に揃えます。

# 1. StandardScaler をインポート
from sklearn.preprocessing import StandardScaler

# 2. データを学習用とテスト用に分割 (今回は30%をテスト用)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 3. スケーラーのインスタンス（実体）を作成
scaler = StandardScaler()

# 4. 【重要】学習用データ (X_train) で「平均・標準偏差を計算(fit)」し、「変換(transform)」する
X_train_scaled = scaler.fit_transform(X_train)

# 5. 【重要】テスト用データ (X_test) は、学習用データで計算した平均・標準偏差を使って「変換(transform)」するだけ
# ※ fit_transform してはいけない！（テストデータの情報を使って学習することになってしまうため）
X_test_scaled = scaler.transform(X_test)

# 6. （確認用）スケーリング後のデータを見てみる
print("--- スケーリング後の X_train (最初の5行) ---")
print(pd.DataFrame(X_train_scaled, columns=X.columns).head())

実行結果を見ると、すべての特徴量が -1.0 や 0.5 のような似たようなスケールの値に変換されていることがわかります。

5-4. モデルの選択と学習 (線形回帰)

回帰タスクで最も基本的で強力なアルゴリズム「線形回帰 (Linear Regression)」を使います。

アルゴリズム紹介：線形回帰

中学数学で習った「一次関数 $y = ax + b$」を思い出してください。線形回帰は、これを多次元（特徴量がたくさんある状態）に拡張したものです。

目的: データ全体に最も当てはまりの良い直線（または平面）を1本引くこと。
式: $y = w_1 x_1 + w_2 x_2 + ... + w_8 x_8 + b$
- y が予測したい住宅価格
- $x_1$〜$x_8$ が8つの特徴量（所得、築年数...）
- $w_1$〜$w_8$ が各特徴量の「重み（重要度）」
- b が切片（バイアス）
学習: Scikit-learnが、fit によって最適な w と b を自動で計算してくれます。

# 1. 線形回帰モデルをインポート
from sklearn.linear_model import LinearRegression

# 2. モデルのインスタンスを作成
model = LinearRegression()

# 3. スケーリング済みの学習用データ (X_train_scaled, y_train) で学習
model.fit(X_train_scaled, y_train)

# 4. （参考）学習結果（w: 重み）を見てみる
# 各特徴量が、価格予測にどれだけ影響を与えているか
print("\n--- 学習した重み (model.coef_) ---")
print(pd.Series(model.coef_, index=X.columns))

実行結果 (重み):

MedInc       0.825877  <- 所得 (MedInc) が高いと、価格も高くなる (正の影響が最も強い)
HouseAge     0.118873
AveRooms    -0.264424
AveBedrms    0.291702
Population  -0.003108
AveOccup    -0.039265
Latitude    -0.893874  <- 緯度 (Latitude) が高い(北)ほど、価格は安くなる (負の影響)
Longitude   -0.860111  <- 経度 (Longitude) が高い(東)ほど、価格は安くなる (負の影響)
dtype: float64

このように、モデルが学習した「重み」を見ることで、どの特徴量が予測に効いているのか解釈できるのも線形回帰の強みです。

5-5. 予測と評価

学習したモデルを使って、テストデータ（X_test_scaled）の住宅価格を予測させます。

# 1. テストデータで予測を実行
y_pred = model.predict(X_test_scaled)

# 2. 予測結果 (y_pred) と 正解 (y_test) を少しだけ見比べる
print(f"\n予測された価格 (y_pred): {y_pred[:5]}")
print(f"実際の価格 (y_test):   {y_test.values[:5]}")

実行結果:

予測された価格 (y_pred): [0.65825227 1.77661665 4.54922904 4.04169724 2.62532454]
実際の価格 (y_test):   [0.477 0.458 5.00001 4.583 2.269]

（単位は10万ドルです）

値はかなり近そうですが、分類の「正解率」のような単純な指標は使えません。

回帰モデルの評価指標

回帰では、「予測と正解の誤差（どれだけズレていたか）」を評価します。

平均二乗誤差 (Mean Squared Error: MSE)
- 意味: （予測 - 正解）の二乗の平均。
- 特徴: 誤差を二乗するため、ズレが大きい（予測を大外しした）データがあると、MSEの値は急激に悪化します。
- 理想: 0 に近いほど良い。
決定係数 (R-squared: R²)
- 意味: 「モデルが、データのどれくらいの割合を説明できているか」を示す指標。
- 特徴: 1.0 (100%) に近いほど、当てはまりが良いモデルと言えます。
- 理想: 1.0 に近いほど良い。（マイナスになることもあります）

# 1. 評価指標をインポート
from sklearn.metrics import mean_squared_error, r2_score

# 2. MSE を計算
# (RMSE: MSEの平方根を取ったもの。元のyと同じ単位になるため解釈しやすい)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse) # np.sqrt は NumPy の平方根
print(f"平均二乗誤差 (MSE): {mse:.4f}")
print(f"平方根平均二乗誤差 (RMSE): {rmse:.4f}")

# 3. 決定係数 (R2) を計算
r2 = r2_score(y_test, y_pred)
print(f"決定係数 (R2): {r2:.4f}")

実行結果:

平均二乗誤差 (MSE): 0.5559
平方根平均二乗誤差 (RMSE): 0.7456
決定係数 (R2): 0.5758

解釈:

RMSE: 平均すると、約 0.74 (x 10万ドル = 7万4千ドル) くらいの予測誤差がある。
R2: 0.5758 (約 57.6%)。これは「モデルが、住宅価格の変動の約57.6%を説明できている」ことを意味します。完璧ではありませんが、まずまずの予測と言えます。

（参考）予測と実際の値をプロット

最後に、予測値（y_pred）と実際の値（y_test）がどれだけ一致しているか、散布図で見てみましょう。

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 8))
# y_test と y_pred を散布図にプロット
plt.scatter(y_test, y_pred, alpha=0.5)

# 理想的な予測（y_test == y_pred）を示す赤い直線を引く
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel("Actual Price (y_test)")
plt.ylabel("Predicted Price (y_pred)")
plt.title("Actual vs Predicted Housing Prices")
plt.show()

グラフの見方:

もし予測が完璧なら、すべての点が赤い破線（y=x の線）の上に並びます。
今回は、全体的に赤い線の周りに集まっており、正の相関（価格が高い物件は高く、安い物件は安く予測できている）が見て取れます。
一方で、特に価格が高い（Actual Price > 4）領域で、予測が低めに出ている（点が赤い線より下にある）傾向もわかります。

お疲れ様でした！これで「分類」と「回帰」という、教師あり学習の2大タスクをマスターしました。

次の章では、正解データ（y）が無い場合にどうするか、「教師なし学習」の世界に入っていきます。

第6章：教師なし学習：クラスタリング (Clustering) 👥

これまでの第4章（分類）と第5章（回帰）は、教師あり学習 (Supervised Learning) と呼ばれる分野でした。これは、予測したい「正解の答え（ターゲット y）」がデータに最初から含まれているものです。

この章では、それとは対照的な「教師なし学習 (Unsupervised Learning)」の代表例である「クラスタリング」を学びます。

6-1. 教師なし学習とは？

教師なし学習とは、正解の答え（y）が与えられていないデータ（X のみ）から、データ自身に潜む「構造」や「パターン」を機械に自動で見つけさせる手法です。

教師あり学習: X（問題）と y（答え）からルールを学ぶ。（例: スパム分類、価格予測）
教師なし学習: X（データ）だけを見て、パターンを学ぶ。（例: グループ分け、パターン発見）

6-2. クラスタリングとは？

クラスタリングは、教師なし学習の中で最も有名で、直感的なタスクです。一言でいえば、「似たもの同士を自動的にグループ分けする」技術です。

正解のグループ分けがわからないデータ（X）を投入すると、モデルがデータ間の類似性を計算し、「このデータとこのデータは似ているから、グループA」「こっちはグループB」というように、自動でクラスタ（集団）を作ってくれます。

例:

顧客の購買履歴や年齢（X）から、似た傾向を持つ「顧客セグメント」に分ける。
大量のニュース記事（X）を、内容が似ている「トピック」ごとに分類する。

6-3. モデルの選択と学習 (K-Means法)

アルゴリズム紹介：K-Means法 (K-平均法)

K-Means（K-へいきんほう）は、クラスタリングアルゴリズムの中で最も広く使われている手法の一つです。

K は「いくつのクラスタに分けたいか」というグループの数を意味します。これは私たちが最初に決める必要があります。
Means は「平均」を意味します。

K-Meansの動作（簡易イメージ）:

まず、K 個の「重心（セントロイド）」をデータ空間にランダムに配置します。
各データ点は、一番近い「重心」のグループに所属します。
各グループの「平均地点（本当の重心）」に、「重心」が移動します。
2と3を、重心がもう動かなくなるまで繰り返します。

データの準備とスケーリング

今回も「Iris (アヤメ) データセット」を使います。しかし、ここが重要なポイントです。

教師なし学習として扱うため、モデルの学習には X (特徴量) しか使いません。
y (実際のアヤメの種類) は、モデルが学習した後で、「答え合わせ」のために使います。

また、K-Meansはデータ間の「距離」を計算するアルゴリズムです。そのため、第5章の回帰と同様に、特徴量のスケールを揃える「スケーリング」が非常に重要です。

# 1. 必要なライブラリをインポート
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler

# 2. データをロード
iris = load_iris()
X = iris.data
y_true = iris.target # y_true (真の答え) として後で使うために保持

# 3. スケーリングを実行
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 4. （確認用）スケーリング後のデータ
print(pd.DataFrame(X_scaled, columns=iris.feature_names).head())

モデルの学習と予測 (`fit_predict`)

それでは、K-Meansモデルを使って X_scaled をクラスタリングします。

Irisデータセットが3種類のアヤメ（Setosa, Versicolor, Virginica）を含んでいることを私たちは「知っている」ので、今回は K=3 ( n_clusters=3 ) と指定します。

# 1. K-Means をインポート
from sklearn.cluster import KMeans

# 2. モデルのインスタンスを作成
# n_clusters=3: 3つのグループに分けてください、という指定
# n_init='auto': 警告を非表示にするためのおまじない
# random_state=0: 実行結果を固定するため
model = KMeans(n_clusters=3, n_init='auto', random_state=0)

# 3. 学習と同時に、各データがどのクラスタに属するかを予測
# .fit(X) で学習し、.predict(X) で予測するのを一度に行う
y_kmeans = model.fit_predict(X_scaled)

# 4. （確認用）予測されたクラスタ番号を見てみる
# 150個のデータが、それぞれ 0, 1, 2 のどれかのクラスタに割り当てられている
print(f"K-Meansが予測したクラスタ: \n{y_kmeans}")

実行結果:

K-Meansが予測したクラスタ: 
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 2 2 2 2 2 0 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2]

y を一切見ていないにも関わらず、モデルがデータを3つのグループ (0, 1, 2) に分けました。

6-4. 結果の可視化と評価

K-Meansが見つけたグループが、実際の種類 (y_true) とどれくらい一致しているか見てみましょう。

「答え合わせ」：実際のラベルと比較

y_kmeans（K-Meansの予測）と y_true（実際の答え）を比較します。

注意点: K-Meansが割り当てるクラスタ番号 0, 1, 2 は、あくまで「グループA, B, C」という意味です。

実際の y_true の 0: setosa, 1: versicolor, 2: virginica と、番号が一致するとは限りません。

（例: K-Meansの「1」が、y_true の「0: setosa」に対応しているかもしれません）

第4章で使った「混同行列」で、どの番号がどの種類に対応していそうか確認します。

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# 1. 混同行列を計算
cm = confusion_matrix(y_true, y_kmeans)

# 2. ヒートマップで可視化
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=['Cluster 0', 'Cluster 1', 'Cluster 2'],
            yticklabels=iris.target_names)
plt.xlabel("Predicted Cluster (K-Means)")
plt.ylabel("Actual Species (y_true)")
plt.show()

実行結果（混同行列）の見方（例）:

Actual 'setosa' (行): 50個すべてが Cluster 1 に分類されている。（K-Meansの「1」が 'setosa' に対応していそう）
Actual 'versicolor' (行): 50個中48個が Cluster 0 に、2個が Cluster 2 に分類されている。（K-Meansの「0」が 'versicolor' に対応していそう）
Actual 'virginica' (行): 50個中36個が Cluster 2 に、14個が Cluster 0 に分類されている。（K-Meansの「2」が 'virginica' に対応していそう）

'setosa' は完璧に分離できていますが、'versicolor' と 'virginica' は一部混ざってしまっていることがわかります。しかし、正解 y を全く見ずに、ここまでグループ分けできたというのは驚くべきことです。

クラスタの可視化

最後に、K-Meansがどのようにデータをグループ分けしたか、可視化してみましょう。

第4章と同様に「花びらの長さ・幅」の2軸でプロットし、色分けを y_kmeans (K-Meansの予測結果) で行います。

また、K-Meansが見つけた各クラスタの「重心」 ( model.cluster_centers_ ) も黒いX印でプロットします。

import numpy as np

# 1. 可視化のために、スケーリング「前」の元データ X を使う
# （花びらの長さと幅）
X_vis = iris.data[:, [2, 3]] 

# 2. スケーリング「後」の重心を取り出す
# ただし、重心は4次元(scaled)なので、可視化のために2次元(scaled)で学習し直す
scaler_vis = StandardScaler()
X_vis_scaled = scaler_vis.fit_transform(X_vis)

model_vis = KMeans(n_clusters=3, n_init='auto', random_state=0)
y_kmeans_vis = model_vis.fit_predict(X_vis_scaled)

# 重心 (scaled) を元のスケールに戻す
centers = scaler_vis.inverse_transform(model_vis.cluster_centers_)

# 3. 散布図をプロット (色分けは y_kmeans_vis)
plt.figure(figsize=(10, 7))
scatter = plt.scatter(X_vis[:, 0], X_vis[:, 1], c=y_kmeans_vis, cmap='viridis', edgecolor='k', s=50)

# 4. 重心をプロット (黒いX印)
plt.scatter(centers[:, 0], centers[:, 1], c='black', marker='x', s=200, label='Cluster Centers')

plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plt.title("K-Means Clustering on Iris Petal (K=3)")
plt.legend()
plt.show()

グラフの見方:

データ点が、K-Meansによって3色に色分けされています。
各色の中心あたりに、黒いX印（重心）が配置されているのがわかります。
この結果を、第4章の「実際の答え」のグラフと見比べると、K-Meansが 'setosa' (左下の塊) を完璧に見つけ、'versicolor' と 'virginica' (右上) を何とか分離しようとしている様子がよくわかります。

お疲れ様でした！これで「教師あり学習」の分類・回帰、そして「教師なし学習」のクラスタリングという、機械学習の3つの主要なタスクをすべて体験しました。

次の章では、現実のデータを扱う上で避けて通れない「データ前処理」について、さらに詳しく学んでいきます。

第7章：実践的ワークフロー：データ前処理 🧹

これまでの章では、Scikit-learnに付属する「きれいな」データセットを使ってきました。しかし、現実世界のデータは汚れています。

データに空欄（欠損値）がある。
「男性/女性」や「東京/大阪」のような文字（カテゴリ）が含まれている。
特徴量ごとの数値のスケール（単位）がバラバラ。

機械学習モデルは、このような生のデータをそのままでは食べられません。この章では、データをモデルが食べられる形に整える「データ前処理 (Data Preprocessing)」という、データサイエンスで最も重要な工程を学びます。

7-1. なぜ前処理が必要なのか？ (Garbage In, Garbage Out)

これはデータサイエンスの有名な格言で、「ゴミを入れれば、ゴミしか出てこない」という意味です。

どんなに高度な機械学習アルゴリズムを使っても、入力するデータが汚れていたり、不適切だったりすれば、得られる予測結果も信頼性の低いもの（ゴミ）になってしまいます。

Scikit-learnは、この前処理を効率的に行うためのツール（Transformer と呼ばれます）を豊富に提供しています。

7-2. 欠損値 (Missing Values) の取り扱い

データが収集される過程で、入力漏れや測定エラーにより「値が無い」状態（欠損値）が発生することがよくあります。Pandasでは NaN (Not a Number) と表示されます。

サンプルデータの作成

まずは、意図的に欠損値（np.nan）を含んだデータを作成します。

import pandas as pd
import numpy as np

# サンプルデータ（身長, 体重, 年齢）
# np.nan が欠損値を表す
data = {
    'Height': [170, 180, 165, np.nan, 175],
    'Weight': [65, np.nan, 55, 75, 70],
    'Age':    [20, 30, 25, 30, 40]
}
X_raw = pd.DataFrame(data)

print("--- 元のデータ (欠損値あり) ---")
print(X_raw)

実行結果:

--- 元のデータ (欠損値あり) ---
   Height  Weight  Age
0   170.0    65.0   20
1   180.0     NaN   30
2   165.0    55.0   25
3     NaN    75.0   30
4   175.0    70.0   40

欠損値の確認

Pandasの .isnull().sum() を使うと、各列に欠損値がいくつあるか簡単に確認できます。

print("\n--- 各列の欠損値の数 ---")
print(X_raw.isnull().sum())

実行結果:

Height    1  <- 1個欠損
Weight    1  <- 1個欠損
Age       0
dtype: int64

欠損値の補完 (Imputation)

Scikit-learnの SimpleImputer を使うと、これらの NaN を特定の値で埋める（補完する）ことができます。

最も一般的なのは、各列の平均値 (mean) で埋める方法です。

# 1. SimpleImputer をインポート
from sklearn.impute import SimpleImputer

# 2. Imputerのインスタンスを作成
# strategy='mean': 平均値で埋める
imputer = SimpleImputer(strategy='mean')

# 3. 学習(fit)と変換(transform)を同時に行う
# fit: 各列の平均値を計算する
# transform: 計算した平均値で NaN を埋める
X_filled = imputer.fit_transform(X_raw)

# 4. （確認用）結果をDataFrameに戻す
X_filled_df = pd.DataFrame(X_filled, columns=X_raw.columns)
print("\n--- 欠損値補完後のデータ ---")
print(X_filled_df)

実行結果:

--- 欠損値補完後のデータ ---
   Height  Weight   Age
0   170.0    65.0  20.0
1   180.0    66.25  30.0  <- (65+55+75+70)/4 = 66.25 で補完された
2   165.0    55.0  25.0
3   172.5    75.0  30.0  <- (170+180+165+175)/4 = 172.5 で補完された
4   175.0    70.0  40.0

NaN だった箇所が、列の平均値で埋められました。

（strategy には median (中央値) や most_frequent (最頻値) も指定できます）

7-3. カテゴリ変数 (Categorical Variables) の取り扱い

機械学習モデルは、基本的に数値しか扱えません。「東京」「Sサイズ」「女性」のような文字（カテゴリ）は、数値に変換する必要があります。

サンプルデータの作成

data_cat = {
    'Size': ['M', 'L', 'S', 'L', 'M'], # 順序があるカテゴリ
    'City': ['Tokyo', 'Osaka', 'Tokyo', 'Nagoya', 'Osaka'] # 順序がないカテゴリ
}
X_cat = pd.DataFrame(data_cat)

print("--- カテゴリデータ ---")
print(X_cat)

1. 順序のあるカテゴリ: `OrdinalEncoder`

「S, M, L, XL」のように、カテゴリ間に順序や大小関係がある場合に使います。

実行結果:

  Size    City  Size_Encoded
0    M   Tokyo           1.0  <- M=1
1    L   Osaka           2.0  <- L=2
2    S   Tokyo           0.0  <- S=0
3    L  Nagoya           2.0
4    M   Osaka           1.0

S=0, M=1, L=2 という、順序関係を保持した数値に変換できました。

2. 順序のないカテゴリ: `OneHotEncoder`

「Tokyo, Osaka, Nagoya」のように、カテゴリ間に順序や大小関係がない（例: Tokyo < Osaka ではない）場合に使います。

もしこれを OrdinalEncoder で Tokyo=0, Osaka=1, Nagoya=2 と変換してしまうと、モデルが「NagoyaはTokyoより2倍大きい」のような誤った関係性を学習してしまいます。

そこで One-Hot Encoding を使います。これは、各カテゴリを「0か1か」で表現する新しい列（ダミー変数）に変換する手法です。

from sklearn.preprocessing import OneHotEncoder

# 1. Encoderのインスタンスを作成
# sparse_output=False: (説明省略) 結果をNumPy配列で得るためのおまじない
onehot_encoder = OneHotEncoder(sparse_output=False)

# 2. 'City'列を変換
city_onehot = onehot_encoder.fit_transform(X_cat[['City']])

# 3. （確認用）結果をDataFrameに変換
# get_feature_names_out() で新しい列名を取得できる
city_df = pd.DataFrame(city_onehot, columns=onehot_encoder.get_feature_names_out(['City']))

print("\n--- OneHotEncoder適用後 ---")
print(city_df)

実行結果:

   City_Nagoya  City_Osaka  City_Tokyo
0          0.0         0.0         1.0  <- 0行目は Tokyo
1          0.0         1.0         0.0  <- 1行目は Osaka
2          0.0         0.0         1.0
3          1.0         0.0         0.0  <- 3行目は Nagoya
4          0.0         1.0         0.0

「City」という1列が、「City_Nagoya」「City_Osaka」「City_Tokyo」という3列に変換され、該当する都市だけが 1 になりました。これでモデルは大小関係を誤解せず、カテゴリを正しく認識できます。

7-4. 特徴量のスケーリング (Feature Scaling)

第5章でも触れましたが、これは非常に重要な前処理です。

StandardScaler（標準化）と MinMaxScaler（正規化）の2つが代表的です。

StandardScaler (標準化):
- 目的: 全ての特徴量を、平均 0、標準偏差 1 に揃える。
- 特徴: 外れ値（極端に大きい/小さい値）がある場合でも、それらの影響を（比較的）保持する。
- 推奨: K-Means, 線形回帰, SVMなど、多くのアルゴリズムで第一選択となる。
MinMaxScaler (正規化):
- 目的: 全ての特徴量を、0 〜 1 の範囲に押し込める。
- 特徴: 全てのデータが厳密に 0〜1 の間に収まる。ただし、外れ値が一つでもあると、他のほとんどのデータが 0 付近に潰れてしまう可能性がある。
- 推奨: 画像データ（ピクセル値 0〜255 を 0〜1 に変換）や、ニューラルネットワークなどで使われる。

from sklearn.preprocessing import StandardScaler, MinMaxScaler

data_scale = {'A': [10, 20, 30, 40, 50],
              'B': [100, 200, 300, 400, 1000]} # 1000は外れ値
X_scale = pd.DataFrame(data_scale)

# StandardScaler
scaler_std = StandardScaler()
X_std = scaler_std.fit_transform(X_scale)
print(f"\n--- StandardScaler (標準化) --- \n平均: {X_std.mean(axis=0)}, 標準偏差: {X_std.std(axis=0)}\n{X_std}")

# MinMaxScaler
scaler_minmax = MinMaxScaler()
X_minmax = scaler_minmax.fit_transform(X_scale)
print(f"\n--- MinMaxScaler (正規化) --- \n最小値: {X_minmax.min(axis=0)}, 最大値: {X_minmax.max(axis=0)}\n{X_minmax}")

7-5. （コラム）VSCodeのデバッガでデータの中身を確認する

Jupyter Notebook (.ipynb) は、セルごとに実行結果が見えるため便利です。

しかし、通常のPythonスクリプト (.py) で複雑な前処理を書いていると、途中でデータがどのような形（shape）や値になっているか不安になることがあります。

そんな時、VSCodeのデバッガが役立ちます。

VSCodeで .py ファイルを開きます。
中身を確認したい行の左側（行番号の横）をクリックします。赤い丸（ブレークポイント）が付きます。
VSCodeの左側のアクティビティバーから「実行とデバッグ (▶虫)」アイコンをクリックします。
「実行とデバッグ」ボタン（緑の三角）を押します。
プログラムが実行され、ブレークポイントを設定した行で一時停止します。
左側の「変数」ペインを見ると、その時点でのすべての変数（X_raw や imputer など）の中身や形状をリアルタイムで確認できます。

複雑な処理を書く際は、print デバッグの代わりに、このデバッガ機能を使うと非常に効率的です。

お疲れ様でした！これで「欠損値」「カテゴリ変数」「スケーリング」という、前処理の3大トピックをマスターしました。

しかし、これらの処理を一つ一つ手作業で行うのは面倒ですし、テストデータへの適用ミス（fit_transform を二重に呼ぶなど）の原因にもなります。

次の章では、これら一連の前処理とモデル学習を一つの「パイプライン」としてまとめ上げ、ワークフローを自動化する強力なテクニックを学びます。

第8章：モデルの精度を高める技術 🛠️

これまでの章で、データの準備から前処理、モデルの学習、評価という一連の流れを学びました。しかし、最初に作ったモデルが常に最高性能とは限りません。

この章では、作ったモデルの「真の実力」をより正しく評価する方法と、モデルの性能をさらに引き出すための「チューニング（調整）」という、一歩進んだテクニックを学びます。

8-1. より良いモデル評価：クロスバリデーション (交差検証)

第4章では、train_test_split を使ってデータを「学習用（70%）」と「テスト用（30%）」の2つに分け、テスト用データで1回だけ精度を評価しました。

この方法の問題点:

たまたま「運の良い（簡単な）データ」がテスト用に行き、スコアが実力以上に高く出てしまう可能性があります。
逆に「運の悪い（難しい）データ」がテスト用に行き、スコアが低く出てしまう可能性もあります。
データの分割の仕方（random_state の値）によって、評価スコアが不安定に変わってしまいます。

解決策：クロスバリデーション (Cross-Validation, CV)

この問題を解決するのが クロスバリデーション (CV) です。これは、データを分割するパターンを何通りも試し、その平均スコアを見ることで、モデルの「真の実力」をより安定して評価する手法です。

K-Fold クロスバリデーション (K=5 の場合):

（テストデータを分ける前の）学習用データを、K個（例: 5個）のグループ（Fold）に分割します。
1回目: Fold 1 を「検証用」、Fold 2〜5 を「学習用」として学習・評価 → スコア1
2回目: Fold 2 を「検証用」、Fold 1, 3, 4, 5 を「学習用」として学習・評価 → スコア2
...
5回目: Fold 5 を「検証用」、Fold 1〜4 を「学習用」として学習・評価 → スコア5
最後に、K回（5回）分のスコアの平均をとります。

この平均スコアは、1回きりの train_test_split よりも遥かに信頼できる「モデルの汎化性能（未知のデータに対する実力）」の指標となります。

`cross_val_score` の使い方

Scikit-learnでは、cross_val_score 関数を使うだけで、この面倒な処理を自動で実行できます。

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.neighbors import KNeighborsClassifier

# 1. データの準備 (Irisデータ)
iris = load_iris()
X = iris.data
y = iris.target

# 2. モデルの準備 (k=3 の k-NN)
model = KNeighborsClassifier(n_neighbors=3)

# 3. クロスバリデーションの実行
# model: 評価したいモデル
# X: 全特徴量, y: 全ターゲット
# cv=5: データを5分割して (K=5) 実行する
scores = cross_val_score(model, X, y, cv=5)

# 4. 結果の確認
print(f"各Foldのスコア: {scores}")
print(f"平均スコア: {scores.mean():.4f}")
print(f"スコアの標準偏差: {scores.std():.4f}")

実行結果:

各Foldのスコア: [0.96666667 1.         0.93333333 0.96666667 1.        ]
平均スコア: 0.9733
スコアの標準偏差: 0.0249

解釈:

train_test_split の時は 97.78% (分割の仕方による) でしたが、CVで評価した結果、このモデルの実力は平均 97.33% であることが、より信頼性高くわかりました。標準偏差が 0.0249 と小さいことから、分割方法にあまり左右されず、安定して高い性能が出ていることもわかります。

8-2. パラメータ調整：グリッドサーチ (Grid Search)

第4章で k-NN を使った時、model = KNeighborsClassifier(n_neighbors=3) と、k=3 を何となく決めました。

もし k=5 だったら？ k=1 だったら？
k=3 が本当に「ベスト」な設定なのでしょうか？

このような、モデルの学習が始まる前に人間が決める設定値（n_neighbors など）を「ハイパーパラメータ」と呼びます。

グリッドサーチ (Grid Search) は、このハイパーパラメータの「最適な組み合わせ」を総当たりで探し出す手法です。

`GridSearchCV` の使い方

GridSearchCV は、以下の2つを組み合わせて実行します。

Grid (格子): 試したいハイパーパラメータの候補を辞書形式で定義します。
CV (Cross-Validation): 各パラメータの組み合わせを、クロスバリデーションで評価します。

from sklearn.model_selection import GridSearchCV

# 1. データの準備 (学習用・テスト用に分けておく)
# グリッドサーチは「学習用データ」だけを使って最適なパラメータを探す
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 2. モデルの準備
model_knn = KNeighborsClassifier()

# 3. 試したいパラメータの「グリッド（辞書）」を定義
# 'n_neighbors' というパラメータを [1, 3, 5, 7, 9, 11] の6パターン試す
param_grid = {
    'n_neighbors': [1, 3, 5, 7, 9, 11]
}

# 4. グリッドサーチのインスタンスを作成
# estimator: 対象モデル
# param_grid: 試すパラメータのグリッド
# cv=5: 各パラメータを5-Fold CVで評価
# n_jobs=-1: PCの全CPUコアを使って並列処理（高速化）
grid_search = GridSearchCV(estimator=model_knn, 
                           param_grid=param_grid, 
                           cv=5, 
                           n_jobs=-1)

# 5. グリッドサーチを実行 (fit)
# X_train と y_train を使って、最適なパラメータを探し出す
grid_search.fit(X_train, y_train)

# 6. 結果の確認
print(f"最適なパラメータ: {grid_search.best_params_}")
print(f"その時のCV平均スコア: {grid_search.best_score_:.4f}")

# 7. （参考）最適なモデルでテストデータを評価
best_model = grid_search.best_estimator_ # 最適な設定で全学習データを使って再学習済み
y_pred = best_model.predict(X_test)
print(f"テストデータでの最終スコア: {accuracy_score(y_test, y_pred):.4f}")

実行結果:

最適なパラメータ: {'n_neighbors': 3}
その時のCV平均スコア: 0.9619
テストデータでの最終スコア: 1.0000

解釈:

k を1, 3, 5, 7, 9, 11と試した結果、k=3 の時（best_params_）にCVの平均スコアが 0.9619 で最高になった、ということが分かりました。（今回のケースでは、たまたま最初の k=3 が最適でした。）

8-3. ワークフローの自動化：Pipeline (パイプライン)

第7章では「前処理」を学びました。第5章では StandardScaler を使いましたが、手順が複雑でした。

scaler = StandardScaler() を作る
X_train で scaler.fit_transform() （学習と変換）
X_test で scaler.transform() （変換のみ！）
model.fit() に X_train_scaled を渡す

この手順は非常にミスをしやすいです。特に、X_test にも fit_transform をしてしまう「データリーケージ（情報の漏洩）」は、重大なバグの原因となります。

解決策：`Pipeline`

Pipeline は、これら一連の処理（前処理 → モデル学習）を「1本のパイプ」として連結する機能です。

Pipeline を使うと、fit と predict を1回呼ぶだけで、Scikit-learnが内部で自動的に適切な処理（fit_transform や transform）を安全に実行してくれます。

`Pipeline` と `GridSearchCV` の組み合わせ

Pipeline の真価は、GridSearchCV と組み合わせた時に発揮されます。これがScikit-learnにおけるモデル構築の「最終形態」とも言えるワークフローです。

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC # k-NNの代わりにSVM（サポートベクターマシン）を使ってみる

# 1. データの準備
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 2. パイプラインの定義
# ('名前', 処理) のタプルのリストを渡す
pipe = Pipeline([
    ('scaler', StandardScaler()),  # ステップ1: スケーラー
    ('svm', SVC(random_state=0))  # ステップ2: SVMモデル
])

# 3. グリッドサーチで「試すパラメータ」の定義
# パラメータ名は「パイプラインでの名前__ハイパーパラメータ名」
param_grid = {
    'svm__C': [0.1, 1, 10],            # SVMの 'C' パラメータ
    'svm__kernel': ['linear', 'rbf']  # SVMの 'kernel' パラメータ
}

# 4. グリッドサーチのインスタンスを作成 (対象は model ではなく pipe)
grid_search_pipe = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)

# 5. グリッドサーチを実行
# この .fit() だけで、CVのたびに
# 1. スケーラーのfit_transform (学習用)
# 2. SVMのfit
# 3. スケーラーのtransform (検証用)
# ... を「安全に」実行してくれる
grid_search_pipe.fit(X_train, y_train)

# 6. 結果の確認
print(f"最適なパラメータ: {grid_search_pipe.best_params_}")
print(f"その時のCV平均スコア: {grid_search_pipe.best_score_:.4f}")

# 7. 最終モデルでテストデータを評価
y_pred_final = grid_search_pipe.predict(X_test)
print(f"テストデータでの最終スコア: {accuracy_score(y_test, y_pred_final):.4f}")

実行結果:

最適なパラメータ: {'svm__C': 10, 'svm__kernel': 'linear'}
その時のCV平均スコア: 0.9619
テストデータでの最終スコア: 1.0000

解釈:

StandardScaler でスケーリングした後、SVMモデルのパラメータを C=10, kernel='linear' に設定するのが、このデータセット（の学習用データ）において最強の組み合わせであることを見つけ出しました。

お疲れ様でした！これで、Scikit-learnの基本的な使い方から、前処理、そしてモデルの性能を最大限に引き出す Pipeline と GridSearchCV という実践的なテクニックまで、全てを学びました。

次の最終章では、ここまでの学びを振り返り、さらにステップアップするための道筋を示します。

第9章：次のステップへ 🏁

Scikit-learnを使った機械学習の旅、ひとまずお疲れ様でした！

本書を通じて、あなたはVSCodeという強力な開発環境を整え、機械学習の基本的な3つのタスク（分類・回帰・クラスタリング）を体験しました。さらに、現実のデータを扱うための前処理、そしてモデルの性能を最大限に引き出すためのPipelineとGridSearchCVという、実践的なワークフローまでを学びました。

ここまでの知識があれば、あなたはもう「機械学習の初学者」を卒業し、自分自身でデータに向き合い、問題を解決していくための強固な土台を手に入れたことになります。

この最終章では、私たちが学んだことを振り返り、さらに深い知識の森へ進むための「次のステップ」を示します。

9-1. 私たちが学んだことの全体像

本書で学んだワークフローは、Scikit-learnを使ったデータ分析の「王道」とも言える流れです。

問題設定とデータ準備
- （load_iris, fetch_california_housing）
データ分割
- （train_test_split）
前処理とモデルの連結
- （StandardScaler, SimpleImputer, OneHotEncoder）
- （Pipeline）
ハイパーパラメータ探索
- （GridSearchCV）
学習と評価
- （fit, predict, accuracy_score, r2_score, cross_val_score）

この流れさえ押さえておけば、これから出会う新しいアルゴリズムやデータセットにも自信を持って対応できるはずです。

9-2. 他の強力なアルゴリズム

本書では、k-NN、線形回帰、K-Means、SVMといった基本的なアルゴリズムに焦点を当てました。Scikit-learnには、これら以外にも強力で広く使われているモデルがたくさんあります。

特に以下の3つは、実務でも非常によく使われるため、次に学ぶ対象として強く推奨します。

決定木 (Decision Tree):
- 「もしAがYesならBへ、NoならCへ」というような「IF-THENルール」の集まりで予測を行います。
- 強み: 結果の解釈が非常にしやすい（なぜその予測になったかがわかる）。
ランダムフォレスト (Random Forest):
- たくさんの（ランダムな）「小さな決定木」を作り、それらの多数決で最終的な予測を行う手法（アンサンブル学習）。
- 強み: 非常に高い予測精度を出すことが多く、過学習（丸暗記）しにくい。特徴量の重要度（どの特徴量が予測に効いているか）もわかります。
勾配ブースティング (Gradient Boosting - XGBoost, LightGBM):
- （Scikit-learn本体ではありませんが、互換性があります）
- 決定木を順番に（直列に）作っていく手法。前の木が間違えた部分を、次の木が重点的に学習して修正していきます。
- 強み: 現在、テーブルデータ（Excelのような表データ）の予測において、最強のアルゴリズムの一つとされています。

これらのアルゴリズムも、Scikit-learnの Pipeline や GridSearchCV にそのまま組み込むことができます。ぜひ挑戦してみてください。

9-3. Scikit-learn公式ドキュメント活用法

今後のあなたの学習において、Scikit-learnの公式ドキュメントは最高の教師であり、リファレンスです。

Scikit-learn Official Website

最初は英語に圧倒されるかもしれませんが、見るべきポイントは決まっています。

User Guide (ユーザガイド):
- 「1. Supervised learning」や「4. Unsupervised learning」など、トピックごとに手法がまとまっています。
- 各アルゴリズムの理論的な背景と、どのような使い方が適しているかが丁寧に解説されています。
API Reference (APIリファレンス):
- sklearn.neighbors.KNeighborsClassifier のように、各クラス（モデル）の使い方を調べる辞書です。
- 最も重要なのは「Parameters (引数)」です。ここで、GridSearchCV で調整できるハイパーパラメータ（n_neighbors や weights など）を知ることができます。
Examples (サンプル集):
- 各アルゴリズムを使ったサンプルコードと、その実行結果（グラフなど）が大量に掲載されています。
- 「やりたいこと」に近いサンプルを見つけてコードをコピーし、自分のデータで試してみるのが最速の学習法です。

9-4. これから学ぶこと（さらなる深みへ）

本書で築いた土台の上には、さらに広大なデータサイエンスの世界が広がっています。

特徴量エンジニアリング (Feature Engineering):
- 「ゴミを入れればゴミしか出ない」の逆で、「良い特徴量（X）を作れば、モデルの精度は劇的に上がる」という分野です。
- （例: 「身長」と「体重」から「BMI」という新しい特徴量を作る、「日付」から「曜日」や「祝日フラグ」を作る、など）
- モデルの選択よりも、この特徴量エンジニアリングの方が精度に与える影響が大きいことも少なくありません。
ディープラーニング (Deep Learning):
- Scikit-learnが（主に）扱わなかった分野です。
- 特に、画像認識や自然言語処理（テキスト）、音声認識といった「非構造化データ」を扱う場合は、ディープラーニング・ライブラリ（TensorFlow や PyTorch）が必須となります。
Kaggleなどのコンペティション:
- 世界中のデータサイエンティストが、同じデータセットを使ってモデルの精度を競うプラットフォームです。
- 他の人がどのような前処理やモデルを使っているか（公開されているNotebook）を見ることは、何よりの学びになります。

最後のメッセージ

機械学習の学習は、登山に似ています。本書で学んだのは、安全に登山（分析）を行うための「装備（VSCode, Python）」と「地図の読み方（ワークフロー）」です。

これからあなたは、様々な山（データセット）に挑戦し、時には道に迷い（エラー）、時には新しいルート（アルゴリズム）を発見するでしょう。そのプロセスこそが、あなたを真のデータサイエンティストへと成長させてくれます。

VSCodeとScikit-learnという強力なツールを手に、ぜひ楽しみながらデータの探索を続けてください。

Happy Data Science!

研修のカリキュラムを見てみる

第1章：はじめに

1-1. 機械学習とは？

AI・機械学習・ディープラーニングの違い

機械学習でできること

1-2. Scikit-learnとは？

Scikit-learnの特徴と立ち位置

なぜScikit-learnが選ばれるのか

1-3. 本書の進め方と学習のゴール

第2章：VSCodeによる開発環境構築 🚀

2-1. なぜVSCodeなのか？

2-2. 必要なツールのインストール

Pythonのインストール

VSCodeのインストールと日本語化

2-3. VSCodeのセットアップ

必須の拡張機能

Pythonインタープリターの選択

2-4. 仮想環境の構築 (venv)

なぜ仮想環境が必要なのか？

VSCodeターミナルでの仮想環境作成

2-5. Scikit-learnと関連ライブラリのインストール

2-6. VSCodeでの実行方法

Jupyter Notebook (.ipynb) の使い方

Pythonスクリプト (.py) のインタラクティブ実行

第3章：機械学習の基本とScikit-learnの作法

3-1. 機械学習の基本的な流れ

3-2. Scikit-learnの重要概念

3-3. Scikit-learnの基本API（統一された操作方法）

1. Estimator (推定量) オブジェクト

2. fit() メソッド：モデルの学習

3. predict() メソッド：未知のデータの予測

4. transform() メソッド：データの前処理 (第7章で詳述)

3-4. Scikit-learnに付属するデータセット

Pandasで表として見やすく表示する

第4章：【実践】最初の機械学習：分類 (Classification)

4-1. 分類とは？

4-2. データの準備

4-3. データの分割 (train_test_split)

4-4. モデルの選択と学習 (fit)

アルゴリズム紹介：k-近傍法 (k-NN)

4-5. 予測と評価 (predict)

正解率 (Accuracy) の計算

（コラム）混同行列 (Confusion Matrix)

4-6. VSCodeのJupyterで結果を可視化する

第5章：教師あり学習：回帰 (Regression) 📈

5-1. 回帰とは？

5-2. データの準備 (California Housing)

5-3. データの分割とスケーリング

5-4. モデルの選択と学習 (線形回帰)

アルゴリズム紹介：線形回帰

5-5. 予測と評価

回帰モデルの評価指標

（参考）予測と実際の値をプロット

第6章：教師なし学習：クラスタリング (Clustering) 👥

6-1. 教師なし学習とは？

6-2. クラスタリングとは？

6-3. モデルの選択と学習 (K-Means法)

アルゴリズム紹介：K-Means法 (K-平均法)

データの準備とスケーリング

モデルの学習と予測 (fit_predict)

6-4. 結果の可視化と評価

「答え合わせ」：実際のラベルと比較

クラスタの可視化

第7章：実践的ワークフロー：データ前処理 🧹

7-1. なぜ前処理が必要なのか？ (Garbage In, Garbage Out)

7-2. 欠損値 (Missing Values) の取り扱い

サンプルデータの作成

欠損値の確認

欠損値の補完 (Imputation)

7-3. カテゴリ変数 (Categorical Variables) の取り扱い

サンプルデータの作成

1. 順序のあるカテゴリ: OrdinalEncoder

2. 順序のないカテゴリ: OneHotEncoder

7-4. 特徴量のスケーリング (Feature Scaling)

7-5. （コラム）VSCodeのデバッガでデータの中身を確認する

第8章：モデルの精度を高める技術 🛠️

8-1. より良いモデル評価：クロスバリデーション (交差検証)

解決策：クロスバリデーション (Cross-Validation, CV)

cross_val_score の使い方

8-2. パラメータ調整：グリッドサーチ (Grid Search)

2. `fit()` メソッド：モデルの学習

3. `predict()` メソッド：未知のデータの予測

4. `transform()` メソッド：データの前処理 (第7章で詳述)

モデルの学習と予測 (`fit_predict`)

1. 順序のあるカテゴリ: `OrdinalEncoder`

2. 順序のないカテゴリ: `OneHotEncoder`

`cross_val_score` の使い方

`GridSearchCV` の使い方

解決策：`Pipeline`

`Pipeline` と `GridSearchCV` の組み合わせ