12. TensorFlow & Kerasで、ディープラーニングの扉を開けよう

第1章: TensorFlowへようこそ

この章から、あなたもAI開発の世界に足を踏み入れます。本書の主役である「TensorFlow (テンソルフロー)」は、AI、特に「機械学習」や「ディープラーニング」と呼ばれる分野で、世界中の開発者や研究者に使われている非常に強力なツールです。

「AIなんて難しそう…」と思うかもしれませんが、心配ありません。この本では、初心者のあなたが一つずつステップを踏みながら、AIモデルを作る楽しさを体験できるように構成されています。

まずは「TensorFlowとは何か？」から、一緒に見ていきましょう。

1.1 TensorFlowとは？

機械学習とディープラーニングの簡単な紹介

まず、言葉の整理をしましょう。

機械学習 (Machine Learning):たくさんのデータ（例: スパムメールの文章、過去の売上データ）をコンピュータに読み込ませ、「パターン」や「ルール」を自動で学習させる技術のことです。「こういう特徴があるメールはスパムだ」とコンピュータ自身が見つけ出します。
ディープラーニング (Deep Learning):機械学習の中でも、特に人間の脳の神経回路（ニューラルネットワーク）の仕組みをヒントに作られた、より強力な学習方法です。特に、画像、音声、テキストのような複雑なデータのパターンを見つけ出すのが得意です。私たちが「AI」と聞いてイメージする技術の多くは、このディープラーニングを使っています。

TensorFlowの役割と主な特徴

TensorFlowは、一言でいうと「ディープラーニングを簡単に行うための『道具箱（ライブラリ）』」です。

もしTensorFlowがなければ、私たちは複雑な数式やアルゴリズムをゼロから書かなければなりません。しかし、TensorFlowが「AIモデルを作るための部品」をたくさん用意してくれているおかげで、私たちはそれらをプラモデルのように組み立てるだけで、AIを開発できます。

Googleが開発: もともとGoogle社内で使われていた技術が元になっており、非常に信頼性が高いです。
オープンソース: 世界中の誰でも無料で使え、開発にも参加できます。
Keras (ケラス) の統合: TensorFlowには「Keras」という、初心者でも驚くほど簡単にAIモデルを作れるインターフェースが組み込まれています。本書では主にこのKerasを使って学んでいきます。

TensorFlowでできること

TensorFlowの力を使うと、以下のようなことができます。

画像認識:写真に写っているのが「犬」なのか「猫」なのかを判別する。手書きの数字を読み取る。
自然言語処理:文章の意味を理解する（例: Webサイトの翻訳、迷惑コメントの自動検出、チャットボット）。
音声認識:話し言葉をテキストに変換する（例: スマートフォンの音声アシスタント）。
予測:過去のデータから、明日の天気、将来の株価、新商品の売上などを予測する。

1.2 なぜTensorFlowを学ぶのか？

数ある機械学習ライブラリの中で、なぜTensorFlowを選ぶのでしょうか？

圧倒的な人気と実績:TensorFlowは、世界中の企業や研究機関で最も広く使われているライブラリの一つです。AI開発の「標準語」とも言えるため、これを学んでおけば、将来さまざまな場面で役立ちます。
学びやすい環境:前述の「Keras」のおかげで、初心者がディープラーニングの基本を学ぶのに最適です。少ないコード量で、直感的にモデルを作ることができます。
豊富な情報とコミュニティ:利用者が多いため、学習のための資料（公式ドキュメント、チュートリアル、ブログ記事）がインターネット上に膨大にあります。エラーで困ったときも、解決策を見つけやすいのが大きな強みです。

1.3 VSCode (Visual Studio Code) で学ぶ理由

本書は「VSCode (Visual Studio Code)」というツールを使って学習を進めます。

VSCodeは、Microsoftが開発した無料の「高機能テキストエディタ」です。単なるメモ帳とは違い、プログラミングを強力にサポートする機能がたくさん詰まっています。

VSCodeの利点と本書での使い方

これ一つで完結:VSCode上でPythonのコードを書くだけでなく、その場で実行し、結果を確認し、間違いを修正する（デバッグ）まで、AI開発に必要な作業がすべて完結します。
Jupyter Notebookが使える:VSCodeは「Jupyter Notebook (ジュピター・ノートブック)」という機能をサポートしています。これは、コードを小さなブロック（セル）に分けて、一つずつ実行し、結果をすぐに見ることができる対話型のツールです。データを分析したり、AIモデルの動作を試したりする際に非常に便利で、学習効率が劇的に上がります。本書でもこのJupyter Notebookをメインに使っていきます。
強力なサポート機能:コードを自動で補完してくれたり、文法の間違いをリアルタイムで教えてくれたりするため、入力ミスが減り、快適にプログラミングに集中できます。

準備はいいですか？

次の章では、早速あなたのPCにVSCodeとTensorFlowをインストールして、AI開発の第一歩を踏み出しましょう！

第2章: 開発環境を整えよう (VSCode & TensorFlow)

TensorFlowを使う準備は、登山に例えるなら「道具を揃えて、登山口に立つ」ことです。難しくありませんので、一つずつ確実にセットアップしていきましょう。

この章では、AI開発の拠点となるVSCodeと、主役であるTensorFlowをあなたのPCにインストールします。

2.1 必要なツールの準備

Pythonのインストール

TensorFlowは「Python (パイソン)」というプログラミング言語の上で動作します。もしPCにPythonが入っていない場合は、先にインストールしましょう。

公式サイトにアクセス:Pythonの公式サイト (python.org) にアクセスし、「Downloads」ページから最新の安定版（例: Python 3.10 や 3.11）をダウンロードします。
インストーラーの実行:ダウンロードしたインストーラーを実行します。⚠️ 重要なチェック:インストール開始画面で、「Add Python X.X to PATH」（または「Add python.exe to Path」）というチェックボックスが必ずONになっていることを確認してください。これを忘れると、後で設定が面倒になります。
インストールの確認:インストール後、「コマンドプロンプト」や「ターミナル」を開き、python --version と入力してエンターキーを押します。Python 3.10.X のようにバージョン番号が表示されれば成功です。

VSCodeのインストール

次に、本書で使う開発ツール「VSCode」をインストールします。

公式サイトにアクセス:VSCodeの公式サイト (code.visualstudio.com) にアクセスします。
ダウンロードとインストール:あなたのOS（Windows, macOS, Linux）に合ったインストーラーをダウンロードし、画面の指示に従ってインストールします。特に難しい設定はありません。

2.2 VSCodeのセットアップ

インストールしたVSCodeを開き、プログラミングをしやすくするための「拡張機能」を追加します。

Python拡張機能のインストールと設定

これはVSCodeでPythonを使うための必須ツールです。

VSCodeの左側にある四角いアイコン（拡張機能ビュー）をクリックします。
検索ボックスに「Python」と入力します。
一番上に出てくる、Microsoftが提供している「Python」拡張機能（青いチェックマーク付き）を選び、「インストール (Install)」ボタンを押します。

Jupyter Notebook拡張機能のインストール

本書では、コードを少しずつ試しながら学べる「Jupyter Notebook」を使います。

先ほどと同じ拡張機能ビューの検索ボックスに「Jupyter」と入力します。
Microsoftが提供している「Jupyter」拡張機能（同じくチェックマーク付き）を選び、「インストール」ボタンを押します。

2.3 TensorFlowのインストール

準備が整ったので、いよいよTensorFlowをインストールします。

💡 プロのヒント: 仮想環境 (venv)

Pythonでは、プロジェクトごとに使うライブラリのバージョンを分ける「仮想環境」を作るのが一般的です。これにより、「AのプロジェクトではTensorFlow 2.10を使うけど、Bのプロジェクトでは最新版を使う」といった使い分けができ、環境が壊れるのを防げます。

本書でも、この「仮想環境」を作ってからTensorFlowをインストールします。

1. プロジェクトフォルダの作成

まず、学習用のフォルダをPCの好きな場所（例: デスクトップやドキュメント）に作ります。ここでは tf-study という名前にしましょう。

2. VSCodeでフォルダを開き、ターミナルを起動

VSCodeを起動し、「ファイル (File)」メニュー > 「フォルダを開く (Open Folder...)」で、先ほど作った tf-study フォルダを選択します。
VSCodeの上部メニューから「ターミナル (Terminal)」 > 「新しいターミナル (New Terminal)」を選びます。画面下にターミナル（黒いコマンド入力画面）が表示されます。

3. 仮想環境の作成 (venv)

ターミナルに以下のコマンドを入力し、エンターキーを押します。（venv という名前の仮想環境フォルダが作られます）

python -m venv venv

4. 仮想環境のアクティベート (有効化)

仮想環境を使うには、まず「有効化」する必要があります。

Windows (コマンドプロンプト/PowerShell) の場合:

.\venv\Scripts\activate

macOS / Linux の場合:

source venv/bin/activate

実行後、ターミナルの行頭に (venv) のような表示が付けば、仮想環境が有効になっています。

5. pipを使ったTensorFlowのインストール

仮想環境が有効な状態で、以下のコマンドを実行します。これがTensorFlow本体のインストールです。

pip install tensorflow

pip はPythonのライブラリを管理するツールです。インターネットからTensorFlowを探してきて、自動でインストールしてくれます。

2.4 インストールの確認

最後に、すべてが正しくインストールされたか確認しましょう。

VSCodeのエクスプローラー（左上のファイルアイコン）で、tf-study フォルダ内に新しいファイルを作成します。名前は test.py としましょう。
test.py を開き、以下のコードをコピーして貼り付けます。

import tensorflow as tf

# TensorFlowのバージョンを表示
print("TensorFlow version:", tf.__version__)

# 簡単なテンソル（データ）を作成
hello = tf.constant("Hello, TensorFlow!")

# テンソルの内容を表示
print(hello.numpy())

コードが書けたら、VSCodeの右下にあるPythonのバージョン表示（例: Python 3.10.X）をクリックします。
上部にコマンドパレットが開くので、./venv/Scripts/python.exe（または venv/bin/python）のように、先ほど作った venv の中のPythonを選択します。（これが「仮想環境のPythonを使う」という設定です）
VSCodeの右上の「▶」（実行）ボタンを押すか、ターミナルで python test.py と入力して実行します。

ターミナルに以下のように表示されれば、インストールは完璧です！

TensorFlow version: 2.X.X  (Xはバージョン番号)
b'Hello, TensorFlow!'

これで、TensorFlowを使ったAI開発のスタートラインに立ちました。

次の章では、TensorFlowがデータを扱う基本単位である「テンソル」について学びます。

第3章: TensorFlowの基本 - データを扱う「テンソル」

環境構築が完了し、いよいよTensorFlowの核心に触れていきます。TensorFlowを使いこなす鍵は、その名前の由来でもある「テンソル (Tensor)」を理解することです。

難しそうに聞こえますが、心配いりません。テンソルとは、突き詰めれば「データの入れ物」のことです。この章では、AIが扱うデータの正体であるテンソルについて学びます。

3.1 テンソル (Tensor) とは？

TensorFlowは、すべてのデータを「テンソル」という形式で扱います。数値、ベクトル、行列、さらには画像のデータも、すべてテンソルとして表現されます。

💡 テンソルとは？

非常に簡単に言えば、「多次元の配列（データの集まり）」です。

スカラー、ベクトル、行列との違い

テンソルは、これらの概念をすべて含んだ、より一般的な「入れ物」です。

スカラー (0階テンソル):単なる1つの数値。例: 5、-1.2
ベクトル (1階テンソル):数値が1列に並んだもの。「1次元配列」とも呼ばれます。例: [1, 2, 3]
行列 (2階テンソル):数値がタテ・ヨコに並んだもの。「2次元配列」や「表」と同じです。例: [[1, 2], [3, 4]]
3階テンソル:行列がさらに重なったもの。「3次元配列」です。例: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

カラー画像は、典型的には「（縦のピクセル数）x（横のピクセル数）x（色の情報3つ: RGB）」で表されるため、3階テンソルとして扱われます。

テンソルの基本属性

テンソルには3つの重要な属性があります。VSCodeのJupyter Notebookでコードを実行しながら確認すると、理解が深まります。

ランク (Rank):テンソルの「次元数」のことです。スカラーはランク0、ベクトルはランク1、行列はランク2です。
シェイプ (Shape):テンソルの「形状」をタプル（数値の組）で表します。各次元にいくつの要素があるかを示します。
- スカラー 5 のシェイプ: ()
- ベクトル [1, 2, 3] のシェイプ: (3,)
- 行列 [[1, 2], [3, 4]] のシェイプ: (2, 2)
データ型 (dtype):テンソルに入っているデータの種類です。tf.float32（32ビット浮動小数点数＝小数）、tf.int32（32ビット整数）などがよく使われます。

3.2 テンソルの作り方

VSCodeで tf-study フォルダ内に chapter3.ipynb という名前のJupyter Notebookファイルを新しく作成し、以下のコードをセルに入力・実行しながら試してみましょう。

（Notebookの使い方が分からない場合は、VSCodeのコマンドパレット（Ctrl+Shift+P または Cmd+Shift+P）で「Jupyter: 新しいJupyter Notebookの作成」を選びます）

`tf.constant()` (定数テンソル)

最も基本的なテンソルの作り方です。constant（定数）という名前の通り、一度作ったら中身を変更できないテンソルです。

# 最初のセルでTensorFlowをインポートします
import tensorflow as tf

# --- スカラー (ランク0) ---
scalar = tf.constant(100)
print("スカラー:", scalar)
print("シェイプ:", scalar.shape)
print("ランク:", scalar.ndim) # .ndimでランクがわかります

# --- ベクトル (ランク1) ---
vector = tf.constant([1, 2, 3, 4, 5])
print("\nベクトル:", vector)
print("シェイプ:", vector.shape)

# --- 行列 (ランク2) ---
matrix = tf.constant([[1, 2], [3, 4]])
print("\n行列:", matrix)
print("シェイプ:", matrix.shape)

# --- データ型を指定して作成 ---
float_tensor = tf.constant([1.0, 2.0], dtype=tf.float32)
print("\n浮動小数点テンソル:", float_tensor)
print("データ型:", float_tensor.dtype)

`tf.Variable()` (変数テンソル)

機械学習では、モデルが学習するにつれて「重み（パラメータ）」と呼ばれる値を更新していく必要があります。このような変更可能なテンソルを作るのが tf.Variable です。

# 変更可能なテンソル（変数）
v = tf.Variable(10.0)
print("変更前:", v)

# .assign() メソッドで値を変更する
v.assign(v + 5.0)
print("変更後:", v)

# tf.Variableは tf.constant で初期化することもできます
initial_value = tf.constant([[1, 2], [3, 4]])
v_matrix = tf.Variable(initial_value)
print("\n変数の行列:\n", v_matrix)

constant（定数）は変更不可、Variable（変数）は変更可能、と覚えてください。モデルの学習には Variable が不可欠です。

3.3 テンソルの基本的な操作

テンソルを使って計算やデータの加工を行います。

四則演算

テンソル同士の計算は、NumPy（Pythonの数値計算ライブラリ）と同じように、要素ごと（同じ位置にある数値同士）に行われます。

a = tf.constant([1, 2, 3])
b = tf.constant([10, 20, 30])

# 足し算
print("足し算:", a + b)

# 掛け算
print("掛け算:", a * b)

# TensorFlowの関数を使うこともできます
print("tf.add:", tf.add(a, b))

# ブロードキャスティング (シェイプが違っても計算できる仕組み)
c = tf.constant(100)
print("\nブロードキャスティング:", a + c) # [1+100, 2+100, 3+100]

インデックスとスライス

テンソルから特定の部分を取り出す操作です。Pythonのリスト操作と似ています。

t = tf.constant([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# 0行目 (ベクトル)
print("0行目:", t[0]) # -> [1, 2, 3]

# 1行目、2列目の要素 (スカラー)
print("1行2列目:", t[1, 2]) # -> 6

# スライス (1行目から最後まで)
print("\n1行目以降:\n", t[1:]) # -> [[4, 5, 6], [7, 8, 9]]

NumPyとの連携

TensorFlowは、Pythonの数値計算ライブラリであるNumPyと非常に相性が良いです。

TensorFlow -> NumPy:numpy() メソッドを使うと、テンソルをNumPy配列に変換できます。
NumPy -> TensorFlow:tf.convert_to_tensor() を使うか、tf.constant() に直接NumPy配列を渡します。

import numpy as np

# NumPy配列の作成
numpy_arr = np.array([[1, 2], [3, 4]])
print("NumPy配列:\n", numpy_arr)

# NumPy -> TensorFlow
tensor_from_numpy = tf.convert_to_tensor(numpy_arr)
print("\nTensorFlowテンソル:\n", tensor_from_numpy)

# TensorFlow -> NumPy
numpy_from_tensor = tensor_from_numpy.numpy()
print("\nNumPy配列に戻す:\n", numpy_from_tensor)

なぜNumPyに変換するの？

テンソルの計算結果をPythonの標準的な数値として扱いたい時や、Matplotlibなどの他のライブラリでグラフを描画する時によく使います。

この章では、TensorFlowの「データ」であるテンソルについて学びました。

次の章では、いよいよこれらのテンソルを使って、AIモデルの「設計図」を組む方法を学びます。いよいよKerasの登場です。

第4章: Keras API入門 - 初めてのモデル構築

いよいよAIモデル、つまり機械学習モデルの構築を始めます。第3章で学んだ「テンソル」（データ）は、モデルの「材料」です。この章では、その材料を使って「モデル」という名の「AIの脳」を設計図から組み立てる方法を学びます。

4.1 Kerasとは？ (TensorFlowの使いやすい窓口)

「TensorFlowのコードは複雑で難しい」と一昔前は言われていました。その問題を解決したのが「Keras (ケラス)」です。

Kerasは、TensorFlowの中で、人間がAIモデルを直感的に、まるでレゴブロックを組み立てるように作れるようにしてくれるインターフェース（窓口）です。

初心者フレンドリー: 複雑な内部処理を隠し、シンプルな命令（API）でモデルを作れます。
TensorFlowと完全統合: 現在、KerasはTensorFlowの公式な一部（tf.keras）となっており、別途インストールする必要はありません。

本書では、この tf.keras を使ってモデル構築を進めます。

4.2 機械学習モデル構築の基本的な流れ

Kerasを使ったモデル構築は、どのタスクでも基本的に以下の流れで行います。

① モデルの定義:「Sequential API」などを使って、層（レイヤー）を積み重ね、モデルの「設計図」を作ります。
② モデルのコンパイル:作ったモデルがどう学習するか（学習方法、間違いの測り方など）を設定します。
③ モデルの学習:データ（テンソル）をモデルに与え、学習（fit）させます。
④ モデルの評価・予測:学習したモデルがどれくらい賢いかを評価（evaluate）し、新しいデータで予測（predict）させます。

この章では、①と②を中心に、③と④のさわりまでを解説します。

4.3 Sequential API でモデルを組む

Kerasにはいくつかモデルの作り方がありますが、最もシンプルで基本となるのが「Sequential (シーケンシャル) API」です。

これは、データの入口から出口まで、層（レイヤー）を一列に（Sequentially）積み重ねてモデルを作る方法です。

レイヤー (Layers) の概念

レイヤーは、AIモデルを構成する「部品」であり、「フィルター」のようなものです。データがレイヤーを通過するたびに、学習に役立つパターンを探すために変換（計算）されます。

`Dense` レイヤー (全結合層)

最も基本的で重要なレイヤーが Dense（デンス＝密な）レイヤーです。これは、前のレイヤーの全ての「ノード（神経細胞のようなもの）」と、次のレイヤーの全てのノードが、線で密に繋がっている層を意味します。

さっそく、VSCodeのJupyter Notebook (chapter4.ipynbなど) で、tf.keras を使ってモデルを定義してみましょう。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# (1) モデルの「設計図」の器を準備
# Sequentialモデルを使います、と宣言
model = Sequential()

# (2) .add() でレイヤー（部品）を追加していく
# 最初のDenseレイヤー。
# units=10: 10個のノード（ニューロン）を持つ層
# activation='relu': 「ReLU」という活性化関数(※)を使う
# input_shape=(8,): このモデルが最初に入力されるデータの形状（シェイプ）
# (※ 最初の層にだけ input_shape が必要)
model.add(Dense(units=10, activation='relu', input_shape=(8,)))

# (3) 2層目（隠れ層）を追加
# 2層目以降は input_shape は不要（自動で計算される）
model.add(Dense(units=5, activation='relu'))

# (4) 最後の層（出力層）を追加
# units=1: 最終的に1つの数値を出力する
model.add(Dense(units=1))

# (5) モデルの設計図を確認
model.summary()

model.summary() を実行すると、今作ったモデルの構造と、学習する「パラメータ（重み）」の数が表示されます。

(※) 活性化関数 (Activation Function) とは？

activation='relu' のように指定するもので、モデルに「複雑な表現力」を与えるために不可欠なものです。「ReLU」は、現在最もよく使われる活性化関数の一つで、「入力がマイナスなら0、プラスならそのまま通す」という単純な処理です。今は「おまじない」のように覚えておけばOKです。

4.4 モデルのコンパイル (学習の準備)

モデルの設計図（Sequential）ができたら、次は「どうやって学習させるか」を設定する compile（コンパイル）という作業を行います。

# model.compile() で3つの重要な設定を行う
model.compile(
    optimizer='adam',      # オプティマイザ (どう学習するか)
    loss='mean_squared_error', # 損失関数 (間違いをどう測るか)
    metrics=['mae']        # メトリクス (何を評価するか)
)

1. オプティマイザ (Optimizer)

役割: 学習を進める「指導役」です。
モデルが予測を間違えた時、その間違い（loss）を最小限にするために、モデルの「パラメータ（重み）」をどのように更新（最適化）するかを決めるアルゴリズムです。
'adam' は、非常に高性能で、ほとんどの場合に良い結果を出してくれる人気のオプティマイザです。迷ったら adam を選べば間違いありません。

2. 損失関数 (Loss Function)

役割: モデルの「間違い度」を測る「採点基準」です。
モデルの予測（答え）と、実際の正解を比較し、どれくらい「間違っているか」を数値（損失＝Loss）で計算します。
モデルは、この「損失」が最小になることを目指して学習します。
'mean_squared_error' (平均二乗誤差) は、予測タスク（回帰）でよく使われる損失関数です。

3. メトリクス (Metrics)

役割: 学習の「進捗確認」のための指標です。
損失関数（loss）は、モデルが学習するために最適化された数値（少し人間には分かりにくい）ですが、メトリクスは、人間が見て分かりやすい「評価指標」です。
['mae'] (Mean Absolute Error, 平均絶対誤差) を指定すると、学習中に「予測が平均してどれくらい正解からズレているか」を表示してくれます。

4.5 モデルの学習 (`fit`)

設計図（Sequential）と学習方針（compile）が決まったら、いよいよデータを与えて学習させます。これには fit (フィット＝適合させる) メソッドを使います。

（※この段階では、まだ実際のデータがないので、コードのイメージだけ掴んでください）

# ダミーのデータ（X_train）と正解（y_train）を準備（第5章で詳しくやります）
# X_train = ... (訓練データ)
# y_train = ... (訓練用の正解)

# モデルの学習 (fit) を実行
# model.fit(
#     X_train,           # 訓練データ
#     y_train,           # 訓練データの正解
#     epochs=10,         # 学習を10周させる
#     batch_size=32      # 32個ずつデータを見て学習する
# )

エポック (Epoch) とバッチサイズ (Batch Size)

エポック (Epoch):用意した訓練データ全体を、モデルが何回繰り返し学習するか、の回数です。epochs=10 は「全データを10周する」という意味です。人間が教科書を何周も読み直して覚えるのに似ています。
バッチサイズ (Batch Size):データを一気に全部見せるのではなく、小さな束（バッチ）に分けてモデルに見せます。batch_size=32 は「データを32個ずつに分けて学習し、全データが終わったら1エポック完了」という意味です。

fit を実行すると、ターミナルやNotebook上に学習の進捗（Epoch 1/10 ... loss: X.XX - mae: Y.YY）がリアルタイムで表示されていきます。

4.6 モデルの評価 (`evaluate`) と予測 (`predict`)

学習が終わったら、モデルが「未知のデータ」に対してどれだけの実力があるかを試します。

評価 (evaluate):学習に使っていない「テストデータ」を与え、モデルの最終的な「成績（loss や metrics）」を計算します。

# X_test = ... (テストデータ)
# y_test = ... (テスト用の正解)
# score = model.evaluate(X_test, y_test)
# print("テストのスコア:", score)

予測 (predict):正解がわからない、全く新しいデータを与えて、モデルに「答え」を予測させます。

# new_data = ... (予測させたい新しいデータ)
# prediction = model.predict(new_data)
# print("モデルの予測結果:", prediction)

この章では、Kerasを使ったモデル構築の「流れ」を学びました。

次の第5章では、実際のデータを使って、この流れに沿って2つの簡単なAIモデル（予測モデルと分類モデル）を作ってみましょう！

第5章: 実践① - 簡単な予測モデルを作ってみよう

第4章で学んだ「Kerasを使ったモデル構築の流れ」を、実際のコードとデータで体験してみましょう。この章では、最も基本的な2種類のタスク「回帰（数値の予測）」と「分類（Yes/Noの予測）」に挑戦します。

5.1 データの準備

AIモデルを学習させるには、データが必要です。この章では、NumPy（第3章で少し触れた数値計算ライブラリ）を使って、学習用の簡単なデータセットを自作します。

chapter5.ipynb などの新しいJupyter Notebookファイルで作業しましょう。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np # NumPyをインポート
import matplotlib.pyplot as plt # グラフ描画ライブラリ

訓練データとテストデータ

モデルを学習させる際、手持ちのデータを「訓練データ（教科書）」と「テストデータ（模擬試験）」に分けるのが一般的です。

訓練データ (Training Data): モデルの学習（fit）に使います。
テストデータ (Test Data): 学習には使わず、学習後にモデルの本当の実力を評価（evaluate）するために使います。

5.2 例題1: 線形回帰 (数値の予測)

タスク: y = 2x + 1 という単純な関係性を持つデータを学習し、x の値から y の値を予測するモデルを作ります。

1. データの準備

y = 2x + 1 という関係に、少しだけランダムなノイズ（誤差）を加えたデータを作ります。

# 訓練データ (x_train) を -1.0 から 1.0 の間で50個作る
x_train = np.linspace(-1.0, 1.0, 50)
# y_train を y = 2x + 1 の関係で作る
y_train = 2 * x_train + 1

# テストデータも同様に作る
x_test = np.linspace(1.1, 2.0, 10)
y_test = 2 * x_test + 1

# データの確認（グラフで見てみましょう）
plt.scatter(x_train, y_train, label='Train')
plt.scatter(x_test, y_test, label='Test')
plt.legend()
plt.show()

2. モデルの定義 (Keras Sequential)

入力は x（1つの数値）、出力は y（1つの数値）です。

非常に単純なので、Dense レイヤーが1つだけのモデルで十分です。

# ① モデルの定義
model_reg = Sequential()

# 入力は1つの数値 (input_shape=(1,))
# 出力も1つの数値 (units=1)
# (活性化関数は指定なし＝線形のまま)
model_reg.add(Dense(units=1, input_shape=(1,)))

model_reg.summary()

3. モデルのコンパイル

「回帰（数値の予測）」タスクです。

損失関数（間違いの測り方）には mean_squared_error (MSE, 平均二乗誤差) が適しています。
オプティマイザには定番の adam を使います。

# ② モデルのコンパイル
model_reg.compile(
    optimizer='adam',
    loss='mean_squared_error' # 回帰タスクの定番
)

4. モデルの学習

fit を使って学習させます。epochs=100 で、全データを100周学習させます。

# ③ モデルの学習
print("学習開始...")
# x_train と y_train を使って学習
history = model_reg.fit(
    x_train,
    y_train,
    epochs=100,
    verbose=0 # verbose=0 にすると学習中のログを非表示にできる
)
print("学習完了！")

5. モデルの評価と予測

評価 (evaluate):テストデータ（x_test, y_test）を使って、学習に使わなかったデータでの「間違い度（loss）」を確認します。
予測 (predict):モデルが何を学習したのか、実際に予測させてみましょう。

# ④ モデルの評価
# テストデータで評価
loss = model_reg.evaluate(x_test, y_test, verbose=0)
print(f"テストデータの損失 (Loss): {loss:.4f}")

# ④ モデルの予測
# x_train と x_test を使って、モデルが予測した y の値を見る
y_pred_train = model_reg.predict(x_train)
y_pred_test = model_reg.predict(x_test)

# 予測結果をグラフで可視化
plt.scatter(x_train, y_train, label='Original Train')
plt.scatter(x_test, y_test, label='Original Test', color='orange')
plt.plot(x_train, y_pred_train, label='Prediction (Train)', color='red')
plt.plot(x_test, y_pred_test, label='Prediction (Test)', color='green')
plt.legend()
plt.show()

学習データ（青）とテストデータ（オレンジ）の点に対し、モデルが学習した予測線（赤と緑）が、ほぼ y = 2x + 1 の直線上に乗っていれば成功です！

5.3 例題2: 2値分類 (Yes/Noの予測)

タスク: x の値が「0より大きいか (Yes=1)」「小さいか (No=0)」を分類するモデルを作ります。

1. データの準備

x はランダムな数値、y は x > 0 なら 1、そうでなければ 0 というデータを作ります。

# 訓練データ (x) をランダムに100個生成
x_train_cls = np.random.rand(100) * 2 - 1 # -1.0 から 1.0 の間の値
# 正解データ (y) を作成 (x > 0 なら 1, それ以外は 0)
y_train_cls = (x_train_cls > 0).astype(int)

# テストデータも同様に作成
x_test_cls = np.random.rand(20) * 2 - 1
y_test_cls = (x_test_cls > 0).astype(int)

# データの確認
plt.scatter(x_train_cls, y_train_cls, label='Train')
plt.scatter(x_test_cls, y_test_cls, label='Test', color='orange')
plt.legend()
plt.show()

2. モデルの定義

今度は「分類」タスクです。

中間層（隠れ層）を1層追加して、モデルに複雑なパターンを学習できるようにします（活性化関数 relu）。
出力層は、0から1の間の確率（例: 0.8 ＝ 80%の確率でYes）を出力する必要があるため、活性化関数 sigmoid（シグモイド）を使います。

# ① モデルの定義
model_cls = Sequential()
model_cls.add(Dense(units=5, activation='relu', input_shape=(1,))) # 中間層
# 出力層: units=1, 活性化関数に 'sigmoid' を指定
model_cls.add(Dense(units=1, activation='sigmoid'))

model_cls.summary()

3. モデルのコンパイル

「2値分類（Yes/No）」タスクです。

損失関数には 'binary_crossentropy' を使います。これは、2値分類の「間違い度」を測るのに最適な関数です。
メトリクス（評価指標）には 'accuracy'（正解率）を指定すると、学習中にモデルがどれくらい正解しているかが見やすくなります。

# ② モデルのコンパイル
model_cls.compile(
    optimizer='adam',
    loss='binary_crossentropy', # 2値分類の定番
    metrics=['accuracy']        # 正解率を監視
)

4. モデルの学習

回帰モデルと同様に fit で学習させます。

# ③ モデルの学習
print("分類モデルの学習開始...")
history_cls = model_cls.fit(
    x_train_cls,
    y_train_cls,
    epochs=100,
    verbose=0 # ログ非表示
)
print("学習完了！")

5. モデルの評価と予測

評価: テストデータでの「正解率（accuracy）」を確認します。
予測: 予測結果は 0 から 1 の「確率」として出力されます。

# ④ モデルの評価
loss, accuracy = model_cls.evaluate(x_test_cls, y_test_cls, verbose=0)
print(f"テストデータの損失 (Loss): {loss:.4f}")
print(f"テストデータの正解率 (Accuracy): {accuracy * 100:.2f}%")

# ④ モデルの予測
# -1.0から1.0までの滑らかなxで予測させてみる
x_smooth = np.linspace(-1.0, 1.0, 100)
y_pred_smooth = model_cls.predict(x_smooth)

# 予測結果をグラフで可視化
plt.scatter(x_train_cls, y_train_cls, label='Original Train')
plt.plot(x_smooth, y_pred_smooth, label='Prediction', color='red')
plt.xlabel('x')
plt.ylabel('Probability (y=1)')
plt.legend()
plt.show()

x=0 を境目にして、予測確率（赤線）が 0 から 1 へと滑らかに変化する「S字カーブ」が描かれていれば大成功です！

この章では、TensorFlow/Kerasを使って、基本的な「回帰」と「分類」のモデルを作りました。

次の章では、AIの得意分野である「画像分類」に挑戦します！

第6章: 実践② - 画像分類に挑戦 (CNN)

これまでは、入力データが x=1.0 のような単純な数値（1次元データ）でした。この章では、AIの最もエキサイティングな分野の一つである「画像分類」に挑戦します。

扱うデータは、ピクセルが並んだ「2次元データ」です。このようなデータを扱うために、ディープラーニングの世界で大成功を収めた「CNN (畳み込みニューラルネットワーク)」という強力なモデルを使います。

6.1 画像データの扱い

コンピュータにとって、画像は単なる「数値の集まり（テンソル）」です。

グレースケール画像（白黒）:「縦ピクセル数 x 横ピクセル数」の2階テンソル（行列）で表されます。各数値は「色の濃さ（0=黒, 255=白）」を示します。
カラー画像:「縦ピクセル数 x 横ピクセル数 x 色（RGBの3チャネル）」の3階テンソルで表されます。

6.2 データセット: MNIST (手書き数字)

今回は、画像分類の「Hello, World!」とも言える、非常に有名な「MNIST (エムニスト) データセット」を使います。これは、0から9までの手書き数字が書かれた白黒画像のコレクションです。

28x28 ピクセルのグレースケール画像
60,000枚の訓練データ
10,000枚のテストデータ

tf.keras.datasets を使えば、このデータを簡単に読み込めます。VSCodeで chapter6.ipynb を作成して進めましょう。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
import matplotlib.pyplot as plt
import numpy as np

# 1. データの読み込み
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# 2. データのシェイプ（形状）を確認
print("訓練データのシェイプ:", x_train.shape) # -> (60000, 28, 28)
print("訓練ラベルのシェイプ:", y_train.shape) # -> (60000,)

# 3. 最初の1枚を見てみる
plt.imshow(x_train[0], cmap='gray')
plt.title(f"正解ラベル: {y_train[0]}")
plt.show()

データの前処理

モデルが学習しやすいように、データを少し加工します。

正規化 (Normalization):現在、ピクセルの値は 0 から 255 です。これを 0.0 から 1.0 の範囲に収めると、学習が安定しやすくなります。
シェイプの変更:この後使うCNNのレイヤー（Conv2D）は、「（バッチサイズ, 縦, 横, チャネル数）」という4階テンソル（4次元配列）を期待します。MNISTは白黒（グレースケール）なので、チャネル数は「1」です。(60000, 28, 28) を (60000, 28, 28, 1) に変更します。

# 1. 正規化 (0-255 を 0-1 の範囲に)
x_train = x_train / 255.0
x_test = x_test / 255.0

# 2. シェイプの変更 (チャネル次元の追加)
# (60000, 28, 28) -> (60000, 28, 28, 1)
x_train = np.expand_dims(x_train, axis=-1)
x_test = np.expand_dims(x_test, axis=-1)

print("加工後の訓練データシェイプ:", x_train.shape)

6.3 畳み込みニューラルネットワーク (CNN) の基本

なぜ第5章で使った Dense レイヤー（全結合層）だけでは画像認識が難しいのでしょうか？

Dense レイヤーは、入力データを1列に並べて（平坦化して）処理します。28x28の画像なら 784個の入力となります。しかし、この方法では「ピクセル同士の位置関係（何が隣にあるか）」という空間的な情報が失われてしまいます。

CNN (Convolutional Neural Network) は、この空間情報を保ったまま「画像の特徴」を抽出するために設計されたネットワークです。

CNNは主に以下の3つのレイヤーを組み合わせて構成されます。

1. `Conv2D` (畳み込み) レイヤー

役割: 画像の「特徴」を抽出します。
動作: 「フィルター（カーネル）」と呼ばれる小さな窓（例: 3x3）を画像の上でスライドさせながら、局所的なパターン（エッジ、線、模様など）を探します。
filters=32: 32種類の異なるフィルター（特徴）を探す、という意味です。

2. `MaxPooling2D` (プーリング) レイヤー

役割: 画像を「圧縮」し、重要な特徴だけを残します。
動作: 小さな領域（例: 2x2）で最も値が大きいピクセルだけを選び、画像のサイズを小さくします。
これにより、計算コストが下がり、わずかな位置ズレにも強くなります。

3. `Flatten` (平坦化) レイヤー

役割: 抽出された2次元の特徴データを、Dense レイヤーで処理できるように「1列に引き伸ばす」役割をします。
CNNの最終段階で、分類を行う Dense レイヤーに渡す直前に使われます。

6.4 CNNモデルの構築と学習

それでは、これらのレイヤーを Sequential モデルで組み立てましょう。

# ① モデルの定義 (CNN)
model_cnn = Sequential()

# --- 特徴抽出部 (CNN) ---
# 1層目: 32種類の3x3フィルターで畳み込み。活性化関数はrelu
model_cnn.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
# 2層目: 2x2の領域でプーリング
model_cnn.add(MaxPooling2D(pool_size=(2, 2)))

# 3層目: 64種類の3x3フィルターで畳み込み
model_cnn.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
# 4層目: 2x2の領域でプーリング
model_cnn.add(MaxPooling2D(pool_size=(2, 2)))

# --- 分類部 (Dense) ---
# 5層目: 1列に平坦化
model_cnn.add(Flatten())
# 6層目: 128個のノードを持つ全結合層
model_cnn.add(Dense(units=128, activation='relu'))
# 7層目: 出力層。分類したいクラス数（0〜9の10個）を units に指定
# 活性化関数は 'softmax' を使う
model_cnn.add(Dense(units=10, activation='softmax'))

model_cnn.summary()

model.summary() を見ると、Conv2D や MaxPooling2D を通過するたびに、画像サイズ（Output Shape の 28x28 や 26x26 の部分）が小さくなり、特徴の数（Param # の後の 32 や 64）が増えていくのが分かります。

`softmax` と `sparse_categorical_crossentropy`

今回は「10クラス分類（0〜9のどれか）」タスクです。

activation='softmax':出力層に使う活性化関数です。10個の出力（0である確率, 1である確率, ... 9である確率）の合計が「1」になるように確率を計算してくれます。
loss='sparse_categorical_crossentropy':多クラス分類で使う定番の損失関数です。
- sparse_ が付く理由: 正解ラベル y_train が [5, 0, 4, ...] のように整数だからです。
- （もし y_train が [0,0,0,0,0,1,0,0,0,0] のような形式（One-Hotエンコーディング）なら categorical_crossentropy を使います）

コンパイルと学習

# ② モデルのコンパイル
model_cnn.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy', # 多クラス分類の定番
    metrics=['accuracy'] # 正解率
)

# ③ モデルの学習
print("CNNモデルの学習開始...")
history_cnn = model_cnn.fit(
    x_train,
    y_train,
    epochs=5, # 5周だけ学習（CNNは学習に時間がかかるため）
    validation_data=(x_test, y_test) # 各エポック後にテストデータで評価
)
print("学習完了！")

fit を実行すると、学習が進むにつれて accuracy（訓練データの正解率）と val_accuracy（テストデータの正解率）が上がっていくのが確認できるはずです。

6.5 学習済みモデルの評価

学習が完了したら、テストデータ全体で最終的な正解率を評価します。

# ④ モデルの評価
test_loss, test_accuracy = model_cnn.evaluate(x_test, y_test, verbose=0)
print(f"\nテストデータの正解率 (Accuracy): {test_accuracy * 100:.2f}%")

おそらく、たった5エポック（数分の学習）でも98%〜99%程度の非常に高い正解率が出たはずです。Dense レイヤーだけを使ったモデルでは到底達成できない精度であり、これがCNNの力です。

（オプション）予測結果をいくつか見てみる

テストデータから1枚取り出して、モデルに予測させてみましょう。

# テストデータの最初の1枚で予測
predictions = model_cnn.predict(x_test[0:1]) # 1枚だけでもシェイプを保つためスライスで指定
predicted_label = np.argmax(predictions) # 確率が最大だったインデックス（＝予測した数字）
actual_label = y_test[0]

# 予測結果の表示
print("モデルの予測:", predictions)
print(f"予測した数字: {predicted_label}")
print(f"実際の数字: {actual_label}")

# 画像を表示
plt.imshow(x_test[0].reshape(28, 28), cmap='gray') # 表示のためシェイプを戻す
plt.title(f"Predicted: {predicted_label}, Actual: {actual_label}")
plt.show()

この章では、画像認識の基本であるCNNを学び、手書き数字の分類に成功しました。

次の章では、モデルの学習をさらに効率化するためのテクニックを学びます。

第7章: Kerasをもう少し使いこなす

第6章では、CNNを使って非常に精度の高い画像分類モデル（model_cnn）を作成できました。しかし、学習には少し時間がかかったはずです。もしPCを再起動したら、学習の成果は消えてしまい、またゼロから学習し直さなければなりません。

この章では、学習の成果を「保存」する方法や、モデルの学習をより賢く行うためのテクニックを学び、Kerasをさらに使いこなしていきましょう。

7.1 モデルの保存と読み込み

Kerasでは、苦労して学習させたモデルの「構造（設計図）」と「学習済みの重み（パラメータ）」を丸ごとファイルに保存できます。

chapter7.ipynb などの新しいNotebookで作業するか、第6章のNotebook（model_cnn が学習済みの状態）で続けて実行してください。

モデルの保存 (`.save()`)

学習済みのモデル（ここでは model_cnn とします）を保存するのは、たった1行で完了します。

# (第6章で学習が完了した model_cnn があると仮定します)

# モデルを 'my_cnn_model.keras' という名前で保存
# 拡張子は .keras が推奨されます
model_cnn.save('my_cnn_model.keras')

print("モデルを保存しました。")

これを実行すると、VSCodeのエクスプローラー（ファイル一覧）に my_cnn_model.keras というファイルが作成されます。このファイルに、モデルのすべてが詰まっています。

モデルの読み込み (`load_model()`)

保存したモデルは、いつでも load_model 関数で読み込めます。PCを再起動した後や、別のプログラムで使う場合に非常に便利です。

from tensorflow.keras.models import load_model

# 保存したモデルを読み込む
loaded_model = load_model('my_cnn_model.keras')

print("モデルを読み込みました。")

# 読み込んだモデルの構造を確認
loaded_model.summary()

# (参考) 第6章のテストデータを読み込んで、読み込んだモデルで評価してみる
# (x_test, y_test) が読み込まれている必要があります
# test_loss, test_accuracy = loaded_model.evaluate(x_test, y_test)
# print(f"読み込んだモデルの正解率: {test_accuracy * 100:.2f}%")

summary() の結果が保存前と一致し、評価結果も同じ（例: 98%以上）になれば、正しく保存・読み込みができています。

7.2 過学習 (Overfitting) を防ぐ

第6章の model_cnn.fit() を実行した際、validation_data を指定したことで、学習中の accuracy（訓練データの正解率）と val_accuracy（テストデータの正解率）が同時に表示されました。

ここで、もし学習（エポック数）をもっと長く続けると、多くの場合次のような現象が発生します。

accuracy（訓練データ）は 99.9% のようにほぼ100%に近づき続ける。
val_accuracy（テストデータ）は、ある時点（例: 98.5%）から逆に下がり始める。

この、「訓練データ（教科書）に最適化されすぎて、未知のテストデータ（模擬試験）への対応力がなくなってしまう」現象を「過学習 (Overfitting)」と呼びます。AIが「答えを丸暗記」してしまい、「応用力」を失った状態です。

過学習を防ぎ、モデルの「応用力（汎化性能）」を高めるための便利な仕組みが「コールバック (Callbacks)」です。

コールバック (Callbacks) の利用

コールバックとは、model.fit() による学習の「特定のタイミング（例: 各エポックの終了時）」に、あらかじめ指定した処理を自動で呼び出す（コールバックする）仕組みです。

ここでは、過学習対策に役立つ2つの主要なコールバックを紹介します。

1. `EarlyStopping` (早期終了)

役割: モデルの「応用力」が下がり始めたら（過学習が始まったら）、それ以上学習しても無駄なので、学習を自動でストップさせます。
使い方:
- monitor='val_loss': テストデータの損失（val_loss）を監視します。
- patience=3: 監視対象の指標（val_loss）が「3エポック」連続で改善しなかったら、学習を停止します。

from tensorflow.keras.callbacks import EarlyStopping

# 早期終了のルールを設定
early_stopping_cb = EarlyStopping(
    monitor='val_loss', # テストデータの損失を監視
    patience=3,         # 3エポック改善しなかったら停止
    verbose=1           # 停止した時にメッセージを表示
)

# (注: このセルは実行イメージです。モデルを再構築・コンパイルする必要があります)
# model.fit(
#     x_train, y_train,
#     epochs=100, # epochsは多めに設定しておく
#     validation_data=(x_test, y_test),
#     callbacks=[early_stopping_cb] # コールバックをリストで指定
# )

epochs=100 と指定しても、例えば10エポック目で val_loss が最小になり、13エポック目まで改善しなければ、そこで学習が自動的に停止します。

2. `ModelCheckpoint` (良いモデルを自動保存)

役割: EarlyStopping は学習を止めてくれますが、止まった時点のモデルが「最高性能」とは限りません（例: 10エポック目が最高で、13エポック目で停止した場合）。
ModelCheckpoint は、監視対象の指標（例: val_accuracy）が過去最高を記録したエポックのモデルだけを自動でファイルに保存してくれます。

from tensorflow.keras.callbacks import ModelCheckpoint

# モデル自動保存のルールを設定
model_checkpoint_cb = ModelCheckpoint(
    filepath='best_model.keras', # 保存するファイル名
    monitor='val_accuracy',      # テストデータの正解率を監視
    save_best_only=True,       # 監視対象が改善した時だけ保存
    mode='max',                # 正解率なので最大(max)を目指す
    verbose=1                  # 保存した時にメッセージを表示
)

# (注: 実行イメージ)
# 2つのコールバックを同時に使う
# model.fit(
#     x_train, y_train,
#     epochs=100,
#     validation_data=(x_test, y_test),
#     callbacks=[early_stopping_cb, model_checkpoint_cb]
# )

この2つを併用すれば、「過学習が始まる手前で学習を自動停止」しつつ、「学習全体で最も性能が良かった瞬間のモデル（best_model.keras）」だけを自動で手元に残すことができ、非常に効率的です。

7.3 (オプション) Functional API

これまで私たちは、Sequential() でモデルを定義し、.add() でレイヤーを一列に積み重ねてきました。これは「Sequential API」と呼ばれる方法で、非常に直感的です。

しかし、モデルが複雑になると（例: 途中で分岐したり、複数の入力を受け取ったりするモデル）、Sequential APIでは対応できません。

そこで使われるのが「Functional API」です。これは、レイヤーを「関数」のように扱い、入力と出力を明示的につなぎ合わせていく、より柔軟なモデル構築方法です。

Sequential API と Functional API の比較

第6章のCNNモデルを、Functional APIで書き換えるとどうなるか比較してみましょう。

（復習）Sequential API:

# model_seq = Sequential()
# model_seq.add(Conv2D(32, (3,3), activation='relu', input_shape=(28, 28, 1)))
# model_seq.add(MaxPooling2D((2, 2)))
# model_seq.add(Flatten())
# model_seq.add(Dense(10, activation='softmax'))

Functional API:

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input

# 1. 入口 (Input) を定義
# データの形状（シェイプ）を指定
inputs = Input(shape=(28, 28, 1))

# 2. レイヤーを関数のように呼び出し、前の層の出力を次の層の入力に渡す
# x = (レイヤー定義)(前の層の出力)
x = Conv2D(32, (3, 3), activation='relu')(inputs)
x = MaxPooling2D((2, 2))(x)
x = Flatten()(x)
outputs = Dense(10, activation='softmax')(x) # 最後の出力

# 3. 入口 (inputs) と 出口 (outputs) を指定してモデル全体を定義
model_func = Model(inputs=inputs, outputs=outputs)

# 4. あとは同じ
model_func.summary()
# model_func.compile(...)
# model_func.fit(...)

Sequential APIが「積み木」だとすれば、Functional APIは「配線」や「関数のパイプライン」を組むイメージです。

初心者のうちは Sequential API だけで十分ですが、より複雑なモデル（有名な学習済みモデルなど）のコードを読む際には、この Functional API の書き方が出てくることを覚えておきましょう。

この章では、モデルの管理方法と、学習を効率化するテクニックを学びました。

次の章では、AI開発の効率をさらに上げる「TensorBoard」による可視化や、次の学習ステップについて紹介します。

第8章: 次のステップへ

ここまで本当にお疲れ様でした！

あなたはTensorFlowの基本的な概念である「テンソル」から始まり、Kerasを使ったモデルの構築（Sequential）、学習（fit）、評価（evaluate）、そして画像認識の王道である「CNN」まで、AI開発の重要なステップを一通り体験しました。

あなたはもう「AI開発の初心者」ではありません。この章では、学習したモデルを「可視化」する方法と、さらにスキルアップするためのネクストステップを紹介し、この入門書を締めくくります。

8.1 TensorBoardによる可視化

model.fit() を実行すると、loss や accuracy がテキストで流れていきましたが、「学習が本当にうまくいったのか？」をグラフで直感的に把握したいと思うはずです。

「TensorBoard (テンソルボード)」は、TensorFlowに標準で搭載されている、学習プロセスを可視化するための強力なダッシュボードツールです。

TensorBoardを使うと、以下のようなことが可能になります。

loss や accuracy の変化をグラフで見る（過学習が起きていないか一目瞭然）
モデルの構造（レイヤーの繋がり）を図で見る
（上級編）モデルが画像のどこに注目しているかを可視化する

VSCode上でのTensorBoardの起動

Kerasのコールバック機能を使うと、学習の履歴をTensorBoard用のログファイルとして自動で保存できます。

1. TensorBoardコールバックの準備

学習ログを保存するためのフォルダ（例: logs）を指定して、コールバックを作成します。

from tensorflow.keras.callbacks import TensorBoard
import datetime # タイムスタンプでログを分けるため

# ログ保存ディレクトリ名を定義 (現在時刻を含め、実行のたびに違う場所にする)
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")

# TensorBoardコールバックの作成
tensorboard_cb = TensorBoard(log_dir=log_dir, histogram_freq=1)

2. model.fit() でコールバックを指定

第7章で使った EarlyStopping などと一緒に、この TensorBoard コールバックも追加して学習を実行します。

# (注: 第6章の model_cnn を再コンパイル・学習するイメージ)

# model_cnn.fit(
#     x_train, y_train,
#     epochs=10,
#     validation_data=(x_test, y_test),
#     callbacks=[tensorboard_cb] # TensorBoardコールバックを指定
# )

学習を実行すると、VSCodeのエクスプローラーに logs フォルダが作成され、その中にログファイルが保存されていきます。

3. TensorBoardの起動

VSCodeでTensorBoardを起動するのは非常に簡単です。

VSCodeのコマンドパレットを開きます（Ctrl+Shift+P または Cmd+Shift+P）。
「TensorBoard: Launch TensorBoard」と入力して選択します。
ログディレクトリの場所を聞かれるので、先ほど作成した logs フォルダを指定します。

これだけで、VSCode内にTensorBoardのダッシュボードが開きます。

「SCALARS」タブを開くと、accuracy や loss がエポックごとにどう変化したかの美しいグラフが表示されます。「GRAPHS」タブでは、Sequential で組んだモデルがどのような構造になっているかを視覚的に確認できます。

8.2 さらに学ぶためのリソース

本書で学んだのは、TensorFlowの広大な世界のほんの入り口です。ここからさらにスキルアップするために役立つリソースを紹介します。

1. TensorFlow Hub (学習済みモデルの活用)

本書ではモデルをゼロから訓練（fit）しましたが、実世界の複雑なタスク（例: もっと高解像度な写真の分類）では、Googleなどが開発した超強力なモデルの「学習済みの重み」を借りてくる「転移学習 (Transfer Learning)」が一般的です。

TensorFlow Hub は、これらの強力な学習済みモデルが数多く公開されているライブラリです。これを活用すれば、自分で何日も学習させることなく、非常に高い精度のモデルをすぐに利用できます。

2. TensorFlow Datasets (便利なデータセット集)

MNIST以外にも、機械学習用の標準的なデータセット（画像、テキスト、音声など）が数多くあります。TensorFlow Datasets (tfds) は、これらのデータセットを tfds.load('dataset_name') のような簡単な命令でダウンロードし、すぐに使える形式で提供してくれるライブラリです。

3. 公式ドキュメントやチュートリアル

TensorFlowの公式ウェブサイトには、VSCode (Jupyter Notebook) でそのまま実行できる、非常に高品質なチュートリアルが豊富に揃っています。

テキスト分類: 文章が「ポジティブ」か「ネガティブ」かを判定する。
時系列予測: 過去のデータから未来の数値を予測する（株価、天気など）。
GANs (敵対的生成ネットワーク): AIに本物そっくりの偽画像を作らせる。

本書で基本の流れ（Kerasの Sequential, compile, fit）をマスターしたあなたなら、これらのチュートリアルもきっと理解できるはずです。

おわりに

TensorFlowとVSCodeを使ったAI開発の旅は、まだ始まったばかりです。AI技術は日々進歩していますが、本書で学んだ「モデルを構築し、データで訓練し、評価する」という基本的な考え方は変わりません。

ぜひ、あなたが興味を持つデータ（好きなスポーツの統計、株価、自作の文章など）を集めて、自分だけの予測モデルや分類モデル作りに挑戦してみてください。

エラーを恐れずに、たくさんのコードを実行し、たくさんのモデルを作ってみることこそが、最強の学習方法です。あなたのこれからのAI開発の旅を応援しています！

付録

A. VSCodeの便利なショートカット (Jupyter Notebook)

VSCodeでの作業効率を上げる、Jupyter Notebook関連の便利なショートカットです。（お使いのOSによって若干異なる場合があります）

操作	Windows / Linux	macOS
コマンドパレットを開く	`Ctrl+Shift+P`	`Cmd+Shift+P`
選択中のセルを実行	`Ctrl+Enter`	`Cmd+Enter`
セルを実行して下に移動	`Shift+Enter`	`Shift+Enter`
セルを実行して下に追加	`Alt+Enter`	`Option+Enter`
（コマンドモードで）上にセルを追加	`A`	`A`
（コマンドモードで）下にセルを追加	`B`	`B`
（コマンドモードで）セルを削除	`D` を2回	`D` を2回
（コマンドモードで）Markdownに切替	`M`	`M`
（コマンドモードで）コードに切替	`Y`	`Y`

💡 コマンドモードとは？

セルの外側（青い枠線）をクリックした状態です。セルの中（緑の枠線）をクリックして文字を入力できる状態は「編集モード」です。「編集モード」中に Esc キーを押すと「コマンドモード」に戻れます。

B. よくあるエラーと対処法

学習中に出会う可能性の高いエラーと、その解決策です。エラーメッセージを恐れずに、じっくり読むことが上達の鍵です。

1. `ModuleNotFoundError: No module named 'tensorflow'`

原因: TensorFlowが正しくインストールされていないか、VSCodeが正しいPython環境（仮想環境）を見ていません。
対処法:
1. VSCodeのターミナルで (venv) のような仮想環境が有効になっているか確認します。
2. 有効になっていなければ、.\venv\Scripts\activate（Win）や source venv/bin/activate（Mac/Linux）で有効化します。
3. VSCodeの右下（または左下）のPythonインタープリタ名をクリックし、作成した venv フォルダ内のPython実行ファイルを選択します。
4. それでもダメなら、ターミナルで pip install tensorflow を再実行します。

2. `ValueError: Shapes (None, X) and (None, Y) are incompatible`

原因: レイヤー間で受け渡されるテンソルの「形状（シェイプ）」が一致していません。
例:
- CNN（Conv2D）から Dense レイヤーに渡す際に、Flatten() レイヤーを入れ忘れている。
- input_shape の指定が間違っている。（例: 28x28の白黒画像なのに input_shape=(28, 28) と指定した。正しくは (28, 28, 1)）
対処法: model.summary() を実行し、各レイヤーの Output Shape を見直します。データがどこで意図しない形状になっているか確認します。

3. `loss` (損失) が `nan` になる

原因: 学習が不安定になり、計算結果が「nan (Not a Number = 非数）」になってしまいました。多くの場合、入力データが大きすぎることが原因です。
対処法:
1. 正規化の確認: 入力データ（特に画像）を 255.0 で割るなどして、0.0〜1.0の範囲にスケーリング（正規化）したか確認します。
2. オプティマイザの学習率: （本書では扱いませんでしたが）オプティマイザの学習率（learning_rate）が高すぎる可能性があります。

4. 分類タスクなのに `accuracy` (正解率) が全く上がらない

原因: モデルの最終層やコンパイルの設定が、タスクと合っていません。
対処法:
- 2値分類 (Yes/No):
  - 最終層: Dense(units=1, activation='sigmoid')
  - コンパイル: loss='binary_crossentropy'
- 多クラス分類 (例: 0〜9の10クラス):
  - 最終層: Dense(units=10, activation='softmax')
  - コンパイル: loss='sparse_categorical_crossentropy'（ラベルが整数の場合）

C. 用語集

本書に登場した重要な用語のまとめです。

TensorFlow (テンソルフロー):Googleが開発した、機械学習・ディープラーニングを行うためのライブラリ（道具箱）。
テンソル (Tensor):TensorFlowがデータを扱う基本単位。数値、ベクトル、行列などを含む「多次元配列」。
Keras (ケラス):TensorFlowの中で、モデルを直感的に（レゴブロックのように）構築できるようにするインターフェース。
レイヤー (Layer):モデルを構成する「部品」や「フィルター」。Dense や Conv2D など。
Sequential API:Kerasでレイヤーを一列に積み重ねてモデルを作る、シンプルで基本的な方法。
Dense (全結合層):前の層の全ノードと、次の層の全ノードが密に接続された、最も基本的なレイヤー。
CNN (畳み込みニューラルネットワーク):画像の空間的な特徴（パターン）を抽出するのが得意なネットワーク。Conv2D と MaxPooling2D が主役。
活性化関数 (Activation Function):モデルに複雑な表現力を与えるための関数。relu や sigmoid, softmax など。
損失関数 (Loss Function):モデルの「間違い度」を測るための関数。モデルはこの値が最小になるよう学習する。mse や binary_crossentropy など。
オプティマイザ (Optimizer):損失関数を最小化するために、モデルの重みをどのように更新（最適化）するかを決めるアルゴリズム。adam が代表的。
エポック (Epoch):訓練データ全体を、モデルが何回繰り返し学習したか、の回数。
バッチサイズ (Batch Size):訓練データを小さな束（バッチ）に分けて学習させるときの、その「束のサイズ」。
過学習 (Overfitting):訓練データに最適化されすぎて、未知のテストデータに対する正解率が下がってしまう現象。「丸暗記」の状態。
正規化 (Normalization):入力データの数値を特定の範囲（例: 0.0〜1.0）に揃えること。学習を安定させるために重要。
コールバック (Callbacks):model.fit() の学習中、特定のタイミングで自動実行される処理。EarlyStopping（早期終了）などで使われる。

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

第1章: TensorFlowへようこそ

1.1 TensorFlowとは？

機械学習とディープラーニングの簡単な紹介

TensorFlowの役割と主な特徴

TensorFlowでできること

1.2 なぜTensorFlowを学ぶのか？

1.3 VSCode (Visual Studio Code) で学ぶ理由

VSCodeの利点と本書での使い方

第2章: 開発環境を整えよう (VSCode & TensorFlow)

2.1 必要なツールの準備

Pythonのインストール

VSCodeのインストール

2.2 VSCodeのセットアップ

Python拡張機能のインストールと設定

Jupyter Notebook拡張機能のインストール

2.3 TensorFlowのインストール

1. プロジェクトフォルダの作成

2. VSCodeでフォルダを開き、ターミナルを起動

3. 仮想環境の作成 (venv)

4. 仮想環境のアクティベート (有効化)

5. pipを使ったTensorFlowのインストール

2.4 インストールの確認

第3章: TensorFlowの基本 - データを扱う「テンソル」

3.1 テンソル (Tensor) とは？

スカラー、ベクトル、行列との違い

テンソルの基本属性

3.2 テンソルの作り方

tf.constant() (定数テンソル)

tf.Variable() (変数テンソル)

3.3 テンソルの基本的な操作

四則演算

インデックスとスライス

NumPyとの連携

第4章: Keras API入門 - 初めてのモデル構築

4.1 Kerasとは？ (TensorFlowの使いやすい窓口)

4.2 機械学習モデル構築の基本的な流れ

4.3 Sequential API でモデルを組む

レイヤー (Layers) の概念

Dense レイヤー (全結合層)

4.4 モデルのコンパイル (学習の準備)

1. オプティマイザ (Optimizer)

2. 損失関数 (Loss Function)

3. メトリクス (Metrics)

4.5 モデルの学習 (fit)

エポック (Epoch) と バッチサイズ (Batch Size)

4.6 モデルの評価 (evaluate) と予測 (predict)

第5章: 実践① - 簡単な予測モデルを作ってみよう

5.1 データの準備

訓練データとテストデータ

5.2 例題1: 線形回帰 (数値の予測)

1. データの準備

2. モデルの定義 (Keras Sequential)

3. モデルのコンパイル

4. モデルの学習

5. モデルの評価と予測

5.3 例題2: 2値分類 (Yes/Noの予測)

1. データの準備

2. モデルの定義

3. モデルのコンパイル

4. モデルの学習

5. モデルの評価と予測

第6章: 実践② - 画像分類に挑戦 (CNN)

6.1 画像データの扱い

6.2 データセット: MNIST (手書き数字)

データの前処理

6.3 畳み込みニューラルネットワーク (CNN) の基本

1. Conv2D (畳み込み) レイヤー

2. MaxPooling2D (プーリング) レイヤー

3. Flatten (平坦化) レイヤー

6.4 CNNモデルの構築と学習

softmax と sparse_categorical_crossentropy

コンパイルと学習

6.5 学習済みモデルの評価

（オプション）予測結果をいくつか見てみる

第7章: Kerasをもう少し使いこなす

7.1 モデルの保存と読み込み

モデルの保存 (.save())

モデルの読み込み (load_model())

7.2 過学習 (Overfitting) を防ぐ

`tf.constant()` (定数テンソル)

`tf.Variable()` (変数テンソル)

`Dense` レイヤー (全結合層)

4.5 モデルの学習 (`fit`)

エポック (Epoch) とバッチサイズ (Batch Size)

4.6 モデルの評価 (`evaluate`) と予測 (`predict`)

1. `Conv2D` (畳み込み) レイヤー

2. `MaxPooling2D` (プーリング) レイヤー

3. `Flatten` (平坦化) レイヤー

`softmax` と `sparse_categorical_crossentropy`

モデルの保存 (`.save()`)

モデルの読み込み (`load_model()`)

1. `EarlyStopping` (早期終了)

2. `ModelCheckpoint` (良いモデルを自動保存)

1. `ModuleNotFoundError: No module named 'tensorflow'`

2. `ValueError: Shapes (None, X) and (None, Y) are incompatible`

3. `loss` (損失) が `nan` になる

4. 分類タスクなのに `accuracy` (正解率) が全く上がらない