STEP 7：Kerasの基本API

ホーム > ディープラーニング基礎 > STEP 7

🧠 STEP 7: Kerasの基本API

Sequentialモデルでニューラルネットワークを構築する方法を学ぼう

📋 このステップで学ぶこと

  • Sequentialモデルとは？モデルの構築方法
  • Denseレイヤー（全結合層）の仕組みとパラメータ数
  • compile()：学習の設定方法
  • fit()：データを使った学習方法
  • evaluate()とpredict()：評価と予測

🎯 1. Sequentialモデルとは？

1-1. Sequentialモデルの基本概念

Sequential（シーケンシャル）モデルとは、層を順番に積み重ねる最もシンプルなモデル構築方法です。
「Sequential」は「順番の」「連続的な」という意味です。

🎂 例え話：ケーキを作るイメージ

Sequentialモデルは、ケーキの層を重ねるように作ります。

スポンジ（入力層）→ クリーム（隠れ層1）→ フルーツ（隠れ層2）→ トッピング（出力層）

下から上へ、1層ずつ順番に積み重ねるのがポイントです。

以下の図は横スクロールできます。

【Sequentialモデルの構造】 データの流れ: 入力 → 隠れ層1 → 隠れ層2 → 出力 ┌─────────────┐ │ 出力層 │ ← 3番目に追加（予測結果を出す） │ Dense(1) │ └──────┬──────┘ ↑ ┌──────┴──────┐ │ 隠れ層2 │ ← 2番目に追加 │ Dense(32) │ └──────┬──────┘ ↑ ┌──────┴──────┐ │ 隠れ層1 │ ← 1番目に追加（input_shape指定） │ Dense(64) │ └──────┬──────┘ ↑ [入力データ] ← 10次元のデータ

1-2. Sequentialモデルの作成方法

Kerasでは、Sequentialモデルを作成する方法が2つあります。

📝 方法1：リストで一度に定義（推奨）

すべての層をリスト（[ ]）の中に書いて、一度に定義する方法です。
コードが簡潔で見やすいため、こちらが推奨されます。

from tensorflow import keras from tensorflow.keras import layers # リストで一度に定義 model = keras.Sequential([ layers.Dense(64, activation=’relu’, input_shape=(10,)), layers.Dense(32, activation=’relu’), layers.Dense(1, activation=’sigmoid’) ])
📝 方法2：add()で1層ずつ追加

空のモデルを作って、add()メソッドで層を1つずつ追加する方法です。
条件によって層を変えたい場合に便利です。

# add()で1層ずつ追加 model = keras.Sequential() model.add(layers.Dense(64, activation=’relu’, input_shape=(10,))) model.add(layers.Dense(32, activation=’relu’)) model.add(layers.Dense(1, activation=’sigmoid’))
💡 Sequentialモデルの特徴
  • シンプル：直感的で理解しやすい
  • 1入力1出力：入力が1つ、出力が1つの構造
  • 制限：分岐や複数入力/出力が必要な場合は使えない
    　　　（その場合はFunctional APIを使う）

🔗 2. Denseレイヤー（全結合層）

2-1. Denseレイヤーとは？

Dense（デンス）レイヤーは、全結合層（Fully Connected Layer）とも呼ばれます。
「Dense」は「密集した」という意味で、前の層のすべてのユニットと、次の層のすべてのユニットがすべて接続されています。

以下の図は横スクロールできます。

【Denseレイヤー（全結合）のイメージ】 前の層（3ユニット） Denseレイヤー（4ユニット） ○──────────────● │╲ ╲ ╲ ╲ │ │ ╲ ╲ ╲ ╲ │ ○──╲──╲──╲──╲─● │ ╲ ╲ ╲ ╲│ │ ╲ ╲ ╲ ╲ ○─────╲──╲──╲──● │ ╲ ╲ ╲ │ │ ╲ ╲ ╲│ ● すべての○からすべての●へ線（重み）が伸びている → これが「全結合」の意味

2-2. Denseレイヤーのパラメータ

📝 Denseレイヤーの書き方

layers.Dense(units, activation, input_shape)

パラメータ 説明 例
units ユニット数（ニューロンの数） 64, 32, 10 など
activation 活性化関数 ‘relu’, ‘sigmoid’, ‘softmax’
input_shape 入力データの形状（最初の層のみ） (10,), (784,) など
📖 具体例

layers.Dense(64, activation=’relu’, input_shape=(10,))

・64 → このレイヤーのユニット数は64個
・activation=’relu’ → ReLU活性化関数を使う
・input_shape=(10,) → 入力は10次元のデータ

2-3. パラメータ数の計算

Denseレイヤーのパラメータ数は、重みとバイアスの合計です。

📐 パラメータ数の計算式

パラメータ数 = (入力次元 × ユニット数) + ユニット数
　　　　　　= 重みの数 + バイアスの数

📊 具体例：入力10次元 → Dense(64)

重みの数 = 10 × 64 = 640
バイアスの数 = 64
パラメータ数 = 640 + 64 = 704

2-4. model.summary()で構造を確認

from tensorflow import keras from tensorflow.keras import layers # 3層のニューラルネットワークを構築 model = keras.Sequential([ layers.Dense(64, activation=’relu’, input_shape=(10,)), # 入力層 → 隠れ層1 layers.Dense(32, activation=’relu’), # 隠れ層1 → 隠れ層2 layers.Dense(1, activation=’sigmoid’) # 隠れ層2 → 出力層 ]) # モデルの構造を表示 model.summary()
実行結果： 
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 64)                704       
                                                                 
 dense_1 (Dense)             (None, 32)                2080      
                                                                 
 dense_2 (Dense)             (None, 1)                 33        
                                                                 
=================================================================
Total params: 2,817
Trainable params: 2,817
Non-trainable params: 0
_________________________________________________________________
📐 パラメータ数の確認

第1層（dense）：704パラメータ
　入力10次元 × 64ユニット + 64バイアス = 10×64 + 64 = 704

第2層（dense_1）：2,080パラメータ
　入力64次元 × 32ユニット + 32バイアス = 64×32 + 32 = 2,080

第3層（dense_2）：33パラメータ
　入力32次元 × 1ユニット + 1バイアス = 32×1 + 1 = 33

⚙️ 3. モデルのコンパイル（compile）

3-1. コンパイルとは？

モデルを構築した後、実際に学習を始める前に学習の設定を行う必要があります。
これがコンパイル（compile）です。

🚗 例え話：車の設定

車（モデル）を作っただけでは走れません。
走る前に設定が必要です：

・どの道を走るか？ → optimizer（最適化アルゴリズム）
・目的地との距離をどう測るか？ → loss（損失関数）
・何を表示するか？ → metrics（評価指標）

3-2. compile()の書き方

📝 compile()の基本構文

model.compile(
    optimizer=’adam’,               # 最適化アルゴリズム
    loss=’binary_crossentropy’,    # 損失関数
    metrics=[‘accuracy’]           # 評価指標
)

3-3. 各パラメータの詳細

🔧 optimizer（最適化アルゴリズム）

損失を最小化するために、重みをどう更新するかを決めます。

  • ‘adam’：最も一般的。迷ったらこれを使う
  • ‘sgd’：シンプルな確率的勾配降下法
  • ‘rmsprop’：RNNでよく使われる
📉 loss（損失関数）

予測と正解の「ずれ」をどう計算するかを決めます。
問題タイプによって使い分けます。

  • ‘mse’：回帰問題（数値予測）
  • ‘binary_crossentropy’：二値分類（2クラス）
  • ‘categorical_crossentropy’：多クラス分類（3クラス以上）
  • ‘sparse_categorical_crossentropy’：多クラス分類（ラベルが整数）
📊 metrics（評価指標）

学習中に表示する指標を決めます。リスト形式で複数指定可能。

  • ‘accuracy’：正解率（分類問題で使用）
  • ‘mae’：平均絶対誤差（回帰問題で使用）
  • ‘mse’：平均二乗誤差

3-4. 問題タイプ別の設定例

# ===== 1. 回帰問題（数値を予測）===== # 例：住宅価格予測、気温予測 model.compile( optimizer=’adam’, loss=’mse’, # 平均二乗誤差 metrics=[‘mae’] # 平均絶対誤差で評価 ) # 出力層: Dense(1) ← 活性化関数なし # ===== 2. 二値分類（2クラス）===== # 例：スパム判定、病気診断 model.compile( optimizer=’adam’, loss=’binary_crossentropy’, # 二値交差エントロピー metrics=[‘accuracy’] # 正解率で評価 ) # 出力層: Dense(1, activation=’sigmoid’) # ===== 3. 多クラス分類（3クラス以上）===== # 例：手書き数字認識、動物分類 model.compile( optimizer=’adam’, loss=’categorical_crossentropy’, # カテゴリカル交差エントロピー metrics=[‘accuracy’] # 正解率で評価 ) # 出力層: Dense(クラス数, activation=’softmax’)
💡 compile()で決める3つのこと
  1. どう最適化するか → optimizer（基本は’adam’）
  2. 何を最小化するか → loss（問題タイプで決まる）
  3. 何を監視するか → metrics（accuracyなど）

🎓 4. モデルの訓練（fit）

4-1. fit()メソッドとは？

モデルをコンパイルしたら、データを使って学習します。
これがfit（フィット）メソッドです。「fit」は「合わせる」「適合させる」という意味です。

📝 fit()の基本構文

history = model.fit(
    x,                        # 訓練データ
    y,                        # 正解ラベル
    batch_size=32,            # バッチサイズ
    epochs=10,                # エポック数
    validation_split=0.2,     # 検証データの割合
    verbose=1                 # 表示レベル
)

4-2. エポック（epoch）とバッチ（batch）を理解する

📚 例え話：教科書で勉強

1000ページの教科書を勉強するとします。

  • バッチ（batch）：一度に読むページ数（例：32ページずつ）
  • エポック（epoch）：教科書全体を何回読むか（例：10回）
📐 具体例：1000サンプル、batch_size=32、epochs=10

1エポックあたりのステップ数 = 1000 ÷ 32 ≈ 32ステップ
全ステップ数 = 32ステップ × 10エポック = 320ステップ

→ 32サンプルずつ処理して、全データを10回繰り返し学習

4-3. 各パラメータの詳細

パラメータ 説明 推奨値
x, y 訓練データと正解ラベル NumPy配列
batch_size 一度に処理するデータ数 32（メモリ不足なら16や8）
epochs 全データを何回学習するか 10〜100（様子を見て調整）
validation_split 検証用に使うデータの割合 0.2（20%）
verbose 表示レベル（0:なし、1:プログレスバー、2:行ごと） 1

4-4. 実装例

📝 コードの解説

np.random.random((1000, 10))

0〜1のランダムな値で、1000サンプル×10次元のダミーデータを作成。

np.random.randint(2, size=(1000, 1))

0または1のランダムな整数で、1000個のラベルを作成（二値分類用）。

validation_split=0.2

データの20%（200サンプル）を検証用に分け、残り80%（800サンプル）で学習。

import numpy as np from tensorflow import keras from tensorflow.keras import layers # ===== ダミーデータの作成 ===== X_train = np.random.random((1000, 10)) # 1000サンプル、10次元 y_train = np.random.randint(2, size=(1000, 1)) # 二値分類のラベル # ===== モデルの構築 ===== model = keras.Sequential([ layers.Dense(64, activation=’relu’, input_shape=(10,)), layers.Dense(32, activation=’relu’), layers.Dense(1, activation=’sigmoid’) ]) # ===== コンパイル ===== model.compile( optimizer=’adam’, loss=’binary_crossentropy’, metrics=[‘accuracy’] ) # ===== 学習 ===== history = model.fit( X_train, y_train, batch_size=32, epochs=10, validation_split=0.2, verbose=1 )
実行結果（例）： 
Epoch 1/10
25/25 [==============================] - 1s 12ms/step - loss: 0.6932 - accuracy: 0.5000 - val_loss: 0.6931 - val_accuracy: 0.5050
Epoch 2/10
25/25 [==============================] - 0s 3ms/step - loss: 0.6930 - accuracy: 0.5062 - val_loss: 0.6929 - val_accuracy: 0.5100
...
Epoch 10/10
25/25 [==============================] - 0s 3ms/step - loss: 0.6915 - accuracy: 0.5387 - val_loss: 0.6912 - val_accuracy: 0.5400
💡 出力の見方
  • 25/25：800サンプル ÷ 32バッチ ≈ 25ステップ
  • loss：訓練データでの損失
  • accuracy：訓練データでの正解率
  • val_loss：検証データでの損失
  • val_accuracy：検証データでの正解率

4-5. historyオブジェクトの活用

fit()の戻り値historyには、学習の履歴が保存されています。
これを使ってグラフを描くことができます。

# historyに保存されているキーを確認 print(history.history.keys()) # dict_keys([‘loss’, ‘accuracy’, ‘val_loss’, ‘val_accuracy’]) # 各エポックの損失を表示 print(“各エポックの損失:”, history.history[‘loss’]) # 学習曲線をグラフ化 import matplotlib.pyplot as plt plt.figure(figsize=(12, 4)) # 損失のグラフ plt.subplot(1, 2, 1) plt.plot(history.history[‘loss’], label=’訓練’) plt.plot(history.history[‘val_loss’], label=’検証’) plt.title(‘損失の推移’) plt.xlabel(‘エポック’) plt.ylabel(‘損失’) plt.legend() # 精度のグラフ plt.subplot(1, 2, 2) plt.plot(history.history[‘accuracy’], label=’訓練’) plt.plot(history.history[‘val_accuracy’], label=’検証’) plt.title(‘精度の推移’) plt.xlabel(‘エポック’) plt.ylabel(‘精度’) plt.legend() plt.tight_layout() plt.show()

📊 5. モデルの評価（evaluate）と予測（predict）

5-1. evaluate()：モデルの評価

学習が終わったら、テストデータでモデルの性能を評価します。
evaluate()は、損失と評価指標を返します。

# テストデータを用意 X_test = np.random.random((200, 10)) y_test = np.random.randint(2, size=(200, 1)) # 評価 test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0) print(f”テスト損失: {test_loss:.4f}”) print(f”テスト精度: {test_accuracy:.4f}”)
実行結果（例）： 
テスト損失: 0.6920
テスト精度: 0.5200
⚠️ なぜテストデータで評価するのか？

訓練データでの精度が高くても、見たことのないデータで良い結果が出るとは限りません。
テストデータは学習に使っていないため、モデルの本当の性能を測ることができます。

5-2. predict()：予測

新しいデータに対して予測を行います。
predict()は、各サンプルの予測値（確率など）を返します。

# 新しいデータで予測 X_new = np.random.random((5, 10)) # 5サンプル # 予測（確率を出力） predictions = model.predict(X_new, verbose=0) print(“予測確率:”) print(predictions) # 二値分類の場合、0.5を閾値にクラスを判定 predicted_classes = (predictions > 0.5).astype(int) print(“\n予測クラス:”) print(predicted_classes)
実行結果（例）： 
予測確率:
[[0.4892]
 [0.5103]
 [0.4756]
 [0.5234]
 [0.4889]]

予測クラス:
[[0]
 [1]
 [0]
 [1]
 [0]]
💡 予測結果の解釈（二値分類の場合）

・予測確率 0.4892 → 50%未満なので クラス0
・予測確率 0.5103 → 50%以上なので クラス1
・予測確率 0.5234 → 50%以上なので クラス1

閾値（しきい値）は通常0.5ですが、目的によって変更することもあります。

5-3. evaluate()とpredict()の違い

メソッド 目的 必要なもの 戻り値
evaluate() モデルの性能評価 データ + 正解ラベル 損失、評価指標
predict() 新しいデータの予測 データのみ 予測値（確率など）

5-4. 完全な実装例（まとめ）

from tensorflow import keras from tensorflow.keras import layers import numpy as np # ===== 1. データの準備 ===== X_train = np.random.random((1000, 10)) y_train = np.random.randint(2, size=(1000, 1)) X_test = np.random.random((200, 10)) y_test = np.random.randint(2, size=(200, 1)) # ===== 2. モデルの構築 ===== model = keras.Sequential([ layers.Dense(64, activation=’relu’, input_shape=(10,)), layers.Dense(32, activation=’relu’), layers.Dense(1, activation=’sigmoid’) ]) # ===== 3. コンパイル ===== model.compile( optimizer=’adam’, loss=’binary_crossentropy’, metrics=[‘accuracy’] ) # ===== 4. 訓練 ===== history = model.fit( X_train, y_train, batch_size=32, epochs=10, validation_split=0.2, verbose=0 # 表示を抑える ) # ===== 5. 評価 ===== test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0) print(f”テスト精度: {test_accuracy:.4f}”) # ===== 6. 予測 ===== X_new = np.array([[0.5, 0.3, 0.8, 0.2, 0.9, 0.1, 0.7, 0.4, 0.6, 0.3]]) prediction = model.predict(X_new, verbose=0) print(f”予測確率: {prediction[0][0]:.4f}”) print(f”予測クラス: {‘クラス1’ if prediction[0][0] > 0.5 else ‘クラス0’}”)
実行結果（例）： 
テスト精度: 0.5150
予測確率: 0.4823
予測クラス: クラス0

📝 STEP 7 のまとめ

✅ このステップで学んだこと
  • Sequentialモデルは層を順番に積み重ねる最もシンプルな方法
  • Denseレイヤーは全結合層で、最も基本的なレイヤー
  • パラメータ数 = (入力次元 × ユニット数) + ユニット数
  • compile()で最適化手法、損失関数、評価指標を設定
  • fit()でデータを使って学習し、historyで履歴を保存
  • evaluate()で評価、predict()で予測
💡 Kerasの基本ワークフロー（5ステップ）

この流れを覚えれば、ほとんどのニューラルネットワークを実装できます！

  1. 構築：Sequential() + Dense() でモデルを作成
  2. コンパイル：compile() で学習設定
  3. 訓練：fit() でデータから学習
  4. 評価：evaluate() で性能評価
  5. 予測：predict() で新しいデータを予測

次のSTEP 8では、実際にMNISTデータセットを使って、
手書き数字認識のニューラルネットワークを実装しましょう！

📝 練習問題

問題1 やさしい

Sequentialモデル

Sequentialモデルについて正しいものを選んでください。

  • A. 複数の入力を持つモデルに最適
  • B. 層を順番に積み重ねるシンプルなモデル
  • C. 分岐構造を持つモデルに最適
  • D. Kerasでは使われなくなった古い方法
正解：B

なぜBが正解なのか？

Sequentialモデルは、「Sequential（順番の）」という名前の通り、
層を順番に積み重ねる最もシンプルなモデル構築方法です。

【Sequentialモデルの構造】 入力 → 層1 → 層2 → 層3 → 出力 ・1つの入力から1つの出力へ ・分岐なしの直線的な構造

他の選択肢の解説：

A、Cが間違い：複数入力や分岐構造には、Functional APIを使います。

Dが間違い：Sequentialは今でも広く使われる標準的な方法です。

問題2 やさしい

Denseレイヤーのパラメータ数

入力が10次元、Denseレイヤーのユニット数が5のとき、パラメータ数はいくつですか？

  • A. 50
  • B. 55
  • C. 15
  • D. 5
正解：B

パラメータ数の計算方法

Denseレイヤーのパラメータは重みとバイアスで構成されます。

【計算式】 パラメータ数 = (入力次元 × ユニット数) + ユニット数 = 重みの数 + バイアスの数 【今回の場合】 入力次元 = 10 ユニット数 = 5 重みの数 = 10 × 5 = 50 バイアスの数 = 5 パラメータ数 = 50 + 5 = 55

なぜバイアスはユニット数分あるのか？

各ユニット（ニューロン）に1つずつバイアス項があるからです。
5ユニットなら、バイアスも5つです。

問題3 ふつう

compile()の設定

住宅価格を予測する回帰問題で、compile()の設定として最も適切なものを選んでください。

  • A. optimizer=’adam’, loss=’mse’, metrics=[‘mae’]
  • B. optimizer=’adam’, loss=’binary_crossentropy’, metrics=[‘accuracy’]
  • C. optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’]
  • D. optimizer=’sgd’, loss=’hinge’, metrics=[‘precision’]
正解：A

なぜAが正解なのか？

住宅価格予測は回帰問題（数値を予測する問題）です。
回帰問題には以下の設定が適切です。

【回帰問題の設定】 optimizer=’adam’ ← 最も一般的な最適化手法 loss=’mse’ ← 平均二乗誤差（回帰問題の標準） metrics=[‘mae’] ← 平均絶対誤差（結果が解釈しやすい）

問題タイプ別の設定チート表：

回帰問題: loss=’mse’, metrics=[‘mae’] 二値分類: loss=’binary_crossentropy’, metrics=[‘accuracy’] 多クラス: loss=’categorical_crossentropy’, metrics=[‘accuracy’]

他の選択肢の解説：

Bが間違い：binary_crossentropyは二値分類用です。
Cが間違い：categorical_crossentropyは多クラス分類用です。

問題4 ふつう

batch_sizeの役割

fit()メソッドのbatch_sizeについて正しいものを選んでください。

  • A. 学習するエポック数を決める
  • B. 一度に処理するデータの数を決める
  • C. 検証データの割合を決める
  • D. モデルの層数を決める
正解：B

batch_sizeとは？

batch_sizeは、一度にGPUで処理するデータの数です。

【batch_sizeの影響】 batch_size=32の場合： ・32サンプルをまとめて処理 ・メモリ使用量：中程度 ・学習速度：バランスが良い batch_size=128の場合： ・128サンプルをまとめて処理 ・メモリ使用量：多い ・学習速度：速いが精度が落ちることも batch_size=8の場合： ・8サンプルをまとめて処理 ・メモリ使用量：少ない ・学習速度：遅いがメモリ不足を回避

メモリ不足時の対処：

batch_size=32でメモリ不足 → 16 → 8 と半分ずつ減らす

他の選択肢の解説：

Aが間違い：エポック数は epochs パラメータで決めます。
Cが間違い：検証データの割合は validation_split で決めます。
Dが間違い：層数はモデル構築時（Sequential）で決めます。

問題5 むずかしい

predict()の出力

3クラス分類（猫、犬、鳥）で、model.predict()の出力が
[[0.7, 0.2, 0.1]] だった場合、正しい解釈を選んでください。

  • A. 猫が70個、犬が20個、鳥が10個
  • B. 猫の確率70%、犬の確率20%、鳥の確率10%
  • C. エラー（確率の合計が1でない）
  • D. クラス0が正解、クラス1とクラス2は不正解
正解：B

多クラス分類の出力を理解しよう

多クラス分類では、出力層にSoftmax活性化関数を使います。
Softmaxは、出力を確率分布（合計1.0）に変換します。

【出力の解釈】 出力: [0.7, 0.2, 0.1] クラス0（猫）: 0.7 = 70% クラス1（犬）: 0.2 = 20% クラス2（鳥）: 0.1 = 10% ───────────────────── 合計: 0.7 + 0.2 + 0.1 = 1.0 (100%) → 最も確率が高い「猫」と予測

予測クラスの取得方法：

import numpy as np predictions = np.array([[0.7, 0.2, 0.1]]) # 最大確率のインデックスを取得 predicted_class = np.argmax(predictions, axis=1) print(predicted_class) # [0] ← インデックス0 = 猫 # クラス名と確率を表示 class_names = [‘猫’, ‘犬’, ‘鳥’] for i, prob in enumerate(predictions[0]): print(f”{class_names[i]}: {prob*100:.1f}%”) # 猫: 70.0% # 犬: 20.0% # 鳥: 10.0%

他の選択肢の解説：

Aが間違い：個数ではなく確率です。
Cが間違い：0.7 + 0.2 + 0.1 = 1.0 なので正常です。
Dが間違い：正解かどうかは、実際のラベルと比較しないとわかりません。

← 前のステップ
STEP 6: TensorFlow/Kerasの環境構築 次のステップへ →
STEP 8: 初めてのニューラルネットワーク実装
📝

学習メモ

ディープラーニング基礎 - Step 7

💾 自動保存 · 0文字
📋 過去のメモ一覧 ▼
#artnasekai #学習メモ
LINE
ホーム
ディープラーニング基礎