---
title: DL_TensorFlow
tags: 
author: [kokuren](https://www.docswell.com/user/kokuren333)
site: [Docswell](https://www.docswell.com/)
thumbnail: https://bcdn.docswell.com/page/KJ4V9GRVE1.jpg?width=480
description: DL_TensorFlow by kokuren
published: November 28, 24
canonical: https://www.docswell.com/s/kokuren333/ZR2EX3-2024-11-28-201928
---
# Page. 1

![Page Image](https://bcdn.docswell.com/page/KJ4V9GRVE1.jpg)

TensorFlow
Tensor
Tensor Operation
Autograph
Eager Execution
Graph Conversion
tf.keras
Control Flow
Sequential Model
Model
Layer
tf.data
Loss Function
Dataset
tf.function
Data Augmentation
Graph Execution
Performance Optimization
tf.distribute
MirroredStrategy
TPUStrategy
Functional API
TensorFlow
定義や意味
TensorFlowは、Google Brainチームによって開発されたオープンソースの機械学習ラ
イブラリ。特にディープラーニングモデルの構築やトレーニングに広く利用されてい
る。
TensorFlowは、数値計算をデータフローグラフ（Data Flow Graph）として表現し、
そのノードを操作する。各ノードは数学的な操作を表し、グラフのエッジはノード間
を流れる多次元配列（テンソル）を表す。
計算を効率的に行うために、CPUやGPUを用いることができ、特に大規模なデータセ
ットの処理においてその性能を発揮する。
嚙み砕いた説明
TensorFlowは、データを処理する際に「テンソル」というデータ構造を使って計算を
行う。テンソルは、多次元の配列で、スカラー（0次元）、ベクトル（1次元）、行列
（2次元）、そしてそれ以上の多次元配列を含む。
データフローグラフは、計算を整理し、どの順序で計算を行うかを指定する。これに
より、大規模で複雑な数値計算を効率的に実行できる。
例えば、画像認識や自然言語処理といった複雑な問題を解くために、ニューラルネッ
トワークを構築し、トレーニングすることが可能。
実際の応用例
TensorFlowは、画像認識、自然言語処理、音声認識、強化学習など、さまざまなアプ
リケーションで使用されている。
以下に、シンプルなニューラルネットワークをTensorFlowで構築するコードスニペッ
トを示す。


# Page. 2

![Page Image](https://bcdn.docswell.com/page/LE13KDQ4JG.jpg)

import tensorflow as tf
from tensorflow.keras import layers, models
# シンプルなニューラルネットワークモデルの定義
model = models.Sequential()
model.add(layers.Dense(128, activation=&#039;relu&#039;, input_shape=(784,)))
model.add(layers.Dense(10, activation=&#039;softmax&#039;))
# モデルのコンパイル
model.compile(optimizer=&#039;adam&#039;,
loss=&#039;sparse_categorical_crossentropy&#039;,
metrics=[&#039;accuracy&#039;])
# データセットの準備（例: MNIST）
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# モデルのトレーニング
model.fit(x_train, y_train, epochs=5)
# モデルの評価
model.evaluate(x_test, y_test, verbose=2)
このコードスニペットは、手書き数字のデータセット（MNIST）を用いて、シンプル
なニューラルネットワークを構築し、トレーニングする例を示す。
モデルは入力層、1つの隠れ層（128ユニット）、および出力層（10ユニット）から構
成され、各ノードが特定の数学的操作を行う。
最適化にはAdamオプティマイザを使用し、誤差関数としてはクロスエントロピーを
用いる。
Tensor
定義や意味
テンソル（Tensor）は数学および物理学における多次元配列を指す。スカラー（0次
元）、ベクトル（1次元）、行列（2次元）を一般化した概念であり、任意の次元を持
つことができる。


# Page. 3

![Page Image](https://bcdn.docswell.com/page/GEWPDYMZJ2.jpg)

テンソルの要素は1つ以上のインデックスによって指定され、次元の数をテンソルの
階数またはランクと呼ぶ。
テンソルは主に機械学習、特にディープラーニングにおいてデータを表現するために
用いられる。
数式で表すと、次のように表現される。ある n 階のテンソル T は Ti1 i2 …in の形式で
表記される。
​
​
​
​
嚙み砕いた説明
テンソルは多次元配列のことで、データを扱うための箱のようなものと考えると理解
しやすい。例えば、画像データは通常3次元テンソルで表される。これは、幅、高
さ、色のチャネルという3つの次元を持つためである。
テンソルを使うと、ベクトルや行列よりもさらに複雑な構造を持ったデータを効率的
に表現できる。
テンソルのランクは次元の数を示す。スカラーはランク0、ベクトルはランク1、行列
はランク2、3次元以上の配列はランク3以上のテンソルと呼ばれる。
実際の応用例
ディープラーニングフレームワークのTensorFlowでは、テンソルを使ってデータを表
現し、計算グラフを通じて効率的に処理する。
例えば、TensorFlowでは以下のようにテンソルを定義し、演算を行うことができる。


# Page. 4

![Page Image](https://bcdn.docswell.com/page/47ZKGXQL73.jpg)

import tensorflow as tf
# 1次元テンソル（ベクトル）の作成
vector = tf.constant([1.0, 2.0, 3.0])
# 2次元テンソル（行列）の作成
matrix = tf.constant([[1.0, 2.0], [3.0, 4.0]])
# 3次元テンソルの作成
tensor_3d = tf.constant([
[[1.0, 2.0], [3.0, 4.0]],
[[5.0, 6.0], [7.0, 8.0]]
])
# テンソルの加算
result = tf.add(vector, [1.0, 1.0, 1.0])
# テンソルの表示
print(&quot;Vector:&quot;, vector.numpy())
print(&quot;Matrix:&quot;, matrix.numpy())
print(&quot;3D Tensor:&quot;, tensor_3d.numpy())
print(&quot;Result of Addition:&quot;, result.numpy())
上記の例では、TensorFlowを用いて異なるランクのテンソルを作成し、テンソルの加
算を行っている。これにより、テンソルの基本的な操作を理解できる。
Autograph
定義や意味
Autographは、TensorFlowにおけるPythonコードをグラフベースの計算に変換するツ
ール。具体的には、Pythonの制御フロー（例えば、 if や for ステートメント）を
TensorFlowの演算グラフとして変換し、より効率的な実行を可能にする。
Autographは、計算グラフを生成することで、TensorFlowの静的グラフモードの利点
（例えば、最適化や分散処理）を享受可能にする。
嚙み砕いた説明
Autographは、Pythonのコードをそのまま書いてもTensorFlowが理解できるように変
換してくれる仕組み。通常、TensorFlowでは演算をグラフとして表現するが、


# Page. 5

![Page Image](https://bcdn.docswell.com/page/YJ6QY46MJV.jpg)

Autographを使うことで、動的なPythonのコードを使いながらも、TensorFlowの静的
グラフの恩恵を受けられる。
例えば、通常Pythonで書くループや条件分岐を、そのままグラフに変換してくれるた
め、プログラムの書き方がより自然でシンプルになる。
実際の応用例
Autographは、特にTensorFlowを用いた機械学習モデルのトレーニングにおいて、
Pythonの柔軟な制御フローとTensorFlowの効率的な計算を組み合わせるために使用さ
れる。
以下のコードスニペットは、Autographを用いた簡単な例を示す。この例では、普通
のPythonの関数をTensorFlowの機能を利用して実行している。
import tensorflow as tf
@tf.function
def my_function(x):
if x &gt; 0:
y = x * x
else:
y = -x
return y
# Autographにより、この関数はグラフモードで実行される
result = my_function(tf.constant(2))
print(result.numpy())
# 出力: 4
result = my_function(tf.constant(-3))
print(result.numpy())
# 出力: 3
このコードでは、 @tf.function デコレータを用いることで、 my_function が
AutographによってTensorFlowのグラフモードで実行されるように変換されている。
これにより、計算が効率的に行われる。
Autographを利用することで、Pythonの制御構造をそのままTensorFlowのグラフに変
換し、GPUやTPUなどのハードウェアアクセラレーションを活用することができる。


# Page. 6

![Page Image](https://bcdn.docswell.com/page/GJ5RGQ6Q74.jpg)

tf.keras
定義や意味
tf.keras は、TensorFlowの高レベルAPIであり、ニューラルネットワークモデルの構
築とトレーニングを簡単に行うためのライブラリ。Kerasはもともと独立したプロジ
ェクトとして開発されていたが、TensorFlow 2.0以降に公式に統合された。
tf.keras はモデルの構築、トレーニング、評価、予測を行うための一連のツールを提
供し、ユーザーが複雑なディープラーニングモデルを迅速に開発できるようにする。
嚙み砕いた説明
tf.keras は、機械学習の初心者でも使いやすいように設計されており、数行のコード
でニューラルネットワークを構築できる高レベルAPI。ユーザーは、モデルの構造を
簡単に定義し、トレーニングや評価を行うことができる。
例えば、 tf.keras を使えば、ニューラルネットワークのレイヤーを積み重ねるように
簡単にモデルを定義でき、学習のための設定もシンプルに行える。
実際の応用例
tf.keras は、画像認識、自然言語処理、音声認識など、さまざまな機械学習タスクで
広く使用されている。
以下に、 tf.keras を用いたシンプルなニューラルネットワークの例を示す。この例で
は、MNISTデータセットを用いて手書き数字の分類を行う。


# Page. 7

![Page Image](https://bcdn.docswell.com/page/9E2DYPMWER.jpg)

import tensorflow as tf
# データセットのロード
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# データの正規化
x_train, x_test = x_train / 255.0, x_test / 255.0
# モデルの定義
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation=&#039;relu&#039;),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10)
])
# モデルのコンパイル
model.compile(optimizer=&#039;adam&#039;,
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[&#039;accuracy&#039;])
# モデルのトレーニング
model.fit(x_train, y_train, epochs=5)
# モデルの評価
model.evaluate(x_test, y_test)
このコードでは、 Sequential モデルを用いて、入力データをフラット化し、2つの全
結合層を持つシンプルなネットワークを構築。最初の全結合層にはReLU活性化関数
を使用し、過学習を防ぐためにドロップアウト層を挿入する。最後に、出力層には10
個のニューロンを持ち、各ニューロンが0から9までの各数字に対応する。モデルは
Adamオプティマイザーでコンパイルされ、クロスエントロピー損失を用いてトレー
ニングされる。
tf.data
定義や意味
tf.data はTensorFlowにおけるデータ処理パイプラインを構築するためのモジュール
である。これにより、大規模なデータセットを効率的に処理し、モデルのトレーニン


# Page. 8

![Page Image](https://bcdn.docswell.com/page/D7Y2G5X97M.jpg)

グをスムーズに行うことが可能となる。
tf.data.Dataset クラスを用いることで、データセットを定義し、変換、バッチ化、
シャッフルなどの操作をチェーンできる。
tf.data APIはイテレータを生成し、データのストリーミング処理を行うため、メモ
リの効率的利用が可能。
データセットは一般に以下の流れで処理される：
i. ソースからデータを読み込む
ii. データを変換する（例：正規化、データ拡張）
iii. データをバッチ化する
iv. データをモデルに供給する
嚙み砕いた説明
tf.data は、TensorFlowで大量のデータを効率的に処理するためのツール。データセ
ットを簡単にロードし、処理し、モデルに渡すまでの流れを簡潔に作成できる。
例えば、画像データを使ったモデルを訓練する際、画像をディスクから読み込み、サ
イズを変更し、正規化し、バッチ化してからモデルに入力する作業を自動化できる。
tf.data を利用することで、データセットの処理が一連のステップとして流れるよう
になるため、コードがきれいで効率的になる。
実際の応用例
画像分類タスクにおけるデータセットの前処理と供給


# Page. 9

![Page Image](https://bcdn.docswell.com/page/VEN8GN1DJ8.jpg)

import tensorflow as tf
# データセットの読み込み
filenames = tf.data.Dataset.list_files(&quot;/path/to/images/*.jpg&quot;)
# 画像の読み込みと前処理
def decode_img(file_path):
img = tf.io.read_file(file_path)
# ファイルを読み込む
img = tf.image.decode_jpeg(img, channels=3)
img = tf.image.resize(img, [224, 224])
img = img / 255.0
# JPEG形式のデコード
# 画像サイズの変更
# 正規化
return img
# データセットの変換
dataset = filenames.map(decode_img)
# バッチ化
batch_size = 32
dataset = dataset.batch(batch_size)
# データのシャッフル
dataset = dataset.shuffle(buffer_size=1000)
# モデルにデータを供給
for batch in dataset:
# ここでモデルのトレーニングを行う
pass
上記のコードでは、画像ファイルを読み込み、サイズを変更し、0から1の範囲に正規
化した後、バッチ化してからモデルに渡すプロセスを示している。
tf.data を使用することで、データの読み込みからモデルへの供給までを効率的に管
理できるため、特に大規模なデータセットでの処理で役立つ。
tf.function
定義や意味
tf.function は、TensorFlowにおいてPython関数をTensorFlowのグラフとして実行可
能にするためのデコレーター


# Page. 10

![Page Image](https://bcdn.docswell.com/page/Y79KWR5873.jpg)

このデコレーターを使うことで、PythonコードをJIT（Just-In-Time）コンパイルし、
TensorFlowの最適化された実行環境で動作させることができる
グラフとして実行することにより、パフォーマンスの向上や、TensorFlowの分散処理
機能を活かすことが可能になる
具体的には、Pythonの関数 f に対して tf.function(f) を適用することで、関数呼
び出し時に動的にグラフが生成され、効率的に計算が行われる
嚙み砕いた説明
tf.function は、Pythonで書いた関数をTensorFlowの効率的な実行環境で動かすため
のツール
通常のPython関数は解釈実行されるが、 tf.function を使うと、関数が事前にコンパ
イルされて、より速く実行できる
たとえば、数値計算を行うループがある場合、 tf.function を使うとそのループの計
算が高速化される
実際の応用例
TensorFlowを用いた機械学習モデルのトレーニングや推論時に、パフォーマンスを向
上させるために使用される
特に大規模データセットや高頻度な演算が必要な場合に、 tf.function は重要な役割
を果たす


# Page. 11

![Page Image](https://bcdn.docswell.com/page/G78RNWYZED.jpg)

import tensorflow as tf
# 通常のPython関数
def simple_add(x, y):
return x + y
# tf.functionを使ってグラフ化する
@tf.function
def optimized_add(x, y):
return x + y
# TensorFlowのテンソルを用意
x = tf.constant([1, 2, 3])
y = tf.constant([4, 5, 6])
# 通常の関数の呼び出し
result_normal = simple_add(x, y)
print(&quot;通常の関数の結果:&quot;, result_normal.numpy())
# tf.functionを用いた関数の呼び出し
result_optimized = optimized_add(x, y)
print(&quot;最適化された関数の結果:&quot;, result_optimized.numpy())
# コメント:
# - `simple_add`は通常のPython関数で、そのまま実行される
# - `optimized_add`は`tf.function`で最適化され、TensorFlowのグラフとして実行される
このコードでは、 simple_add は通常のPython関数であり、 optimized_add は tf.function デ
コレーターを使用してグラフ化されている。これにより、 optimized_add はTensorFlowの最
適化された実行エンジンで効率的に動作する。
tf.distribute
定義や意味
tf.distribute はTensorFlowで提供されるAPIであり、計算を複数のデバイス
（GPU、TPU、CPUなど）や複数のマシンにわたって分散させるための機能を提供す
る
データ並列処理を実現するための方法を提供し、モデルのトレーニングを効率的にス
ケールさせることが可能


# Page. 12

![Page Image](https://bcdn.docswell.com/page/L7LKPN41ER.jpg)

ユーザーが記述したコードのほとんどを変更せずに、計算資源を最大限に活用できる
ように設計されている
嚙み砕いた説明
tf.distribute は、機械学習モデルのトレーニングをより速くするために、計算を複
数のコンピュータやプロセッサに分散させるための仕組み
例えば、1つのGPUだけでなく、複数のGPUやTPUを使うことで、データを並列処理
し、トレーニング時間を短縮する
特に大量のデータを扱う際に、有効な手段となる
実際の応用例
tf.distribute.Strategy を使用して、モデルのトレーニングを複数のデバイスに分散
させる
例えば、 tf.distribute.MirroredStrategy を用いて、1台のマシンに搭載された複数の
GPUを使用することができる
import tensorflow as tf
# MirroredStrategyを使用して、同一マシン内の複数GPUを使用
strategy = tf.distribute.MirroredStrategy()
# Strategyのスコープ内でモデルとオプティマイザを定義
with strategy.scope():
model = tf.keras.Sequential([
tf.keras.layers.Dense(128, activation=&#039;relu&#039;, input_shape=(784,)),
tf.keras.layers.Dense(10, activation=&#039;softmax&#039;)
])
model.compile(loss=&#039;sparse_categorical_crossentropy&#039;,
optimizer=tf.keras.optimizers.Adam(),
metrics=[&#039;accuracy&#039;])
# データの準備
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# モデルのトレーニング
model.fit(x_train, y_train, epochs=5, batch_size=64)
上記のコードでは、 MirroredStrategy を使用して、同一マシン内の複数のGPUを活用


# Page. 13

![Page Image](https://bcdn.docswell.com/page/4EM24XK5EW.jpg)

strategy.scope() 内でモデルとオプティマイザを定義することで、分散トレーニング
を容易に実現
データはMNISTデータセットを使用しており、単純なニューラルネットワークモデル
を構築している
Tensor Operation
定義や意味
テンソル（Tensor）は、スカラー（0次元）、ベクトル（1次元）、行列（2次元）の
一般化されたもので、任意の次元数を持つ配列として定義される
テンソル演算（Tensor Operation）は、これらのテンソルに対して行われる様々な操
作を指す
具体的な演算には、テンソルの加算、減算、内積、外積、転置、リシェイプ
（reshape）などが含まれる
数式で表現すると、例えば、テンソルの加算は次のように書ける
2つのテンソル A と B の加算: C = A + B
嚙み砕いた説明
テンソルは、単純な数（スカラー）や1次元の数の並び（ベクトル）、2次元の数の配
列（行列）をさらに拡張したもので、多次元の数の配列
テンソル演算は、これらの多次元配列に対して行う計算のことを指し、数学的な操作
やデータ変換を行う
例えば、2つの画像を重ね合わせる操作もテンソル演算の一部として捉えることがで
きる
実際の応用例
テンソル演算は、機械学習、特にディープラーニングの分野で広く使用されており、
ニューラルネットワークの訓練や推論において不可欠な要素
TensorFlowのようなフレームワークでは、テンソルを用いてモデルの入力データや重
みを表現し、それらに対する様々な演算を行う
以下にTensorFlowを用いたテンソルの基本的な演算の例を示す


# Page. 14

![Page Image](https://bcdn.docswell.com/page/PERMWNXZ79.jpg)

import tensorflow as tf
# テンソルの定義
tensor_a = tf.constant([[1, 2], [3, 4]])
tensor_b = tf.constant([[5, 6], [7, 8]])
# テンソルの加算
tensor_sum = tf.add(tensor_a, tensor_b)
print(&quot;テンソルの加算結果:&quot;)
print(tensor_sum.numpy())
# テンソルの要素ごとの乗算
tensor_mul = tf.multiply(tensor_a, tensor_b)
print(&quot;\nテンソルの要素ごとの乗算結果:&quot;)
print(tensor_mul.numpy())
# テンソルの転置
tensor_transposed = tf.transpose(tensor_a)
print(&quot;\nテンソルの転置結果:&quot;)
print(tensor_transposed.numpy())
# テンソルのリシェイプ
tensor_reshaped = tf.reshape(tensor_a, [4, 1])
print(&quot;\nテンソルのリシェイプ結果:&quot;)
print(tensor_reshaped.numpy())
このコードでは、テンソルの加算、要素ごとの乗算、転置、リシェイプを行っている
TensorFlowを用いることで、テンソル演算を効率的に実行でき、多くの計算資源を節
約できる
Eager Execution
定義や意味
Eager Execution（イージャーエグゼキューション）は、TensorFlowにおけるプログ
ラミングの実行モードの一つで、コードが書かれるとすぐに実行されるという特徴を
持つ。これは、デフォルトのグラフ構築モードに対して、より直感的でデバッグが容
易な方法を提供する。
通常のグラフモードでは、計算グラフを事前に構築し、その後に実行する。一方、
Eager Executionでは、Pythonの命令が記述されると即座に実行され、即時に結果が


# Page. 15

![Page Image](https://bcdn.docswell.com/page/P7XVPN61JX.jpg)

得られる。
数式的に言えば、通常のグラフモードは以下のように、まず関数を定義する段階と実
行する段階が分かれている。
グラフモード : {
計算グラフを構築
計算グラフを実行
​
これに対して、Eager Executionでは、命令が与えられると随時実行される。
Eager Execution : 命令 → 即時実行
嚙み砕いた説明
Eager Executionは、Pythonの通常の命令と同様に、コードを書きながらその結果を
すぐに確認できるため、学習やデバッグがしやすい。これは、特にデータの前処理や
モデルのデバッグ、実験的なプロトタイピングにおいて非常に便利。
直感的には、Eager Executionは電卓のようなものをイメージすると良い。ボタンを押
したらすぐに結果が表示される。これに対して、グラフモードは、計算式を書き出し
てから最終的に「計算する」ボタンを押すようなものと言える。
実際の応用例
TensorFlowでEager Executionを利用することで、簡単にテンソルの操作やモデルの
デバッグが可能になる。以下は、Eager Executionを用いてテンソルの基本的な操作を
行う例。


# Page. 16

![Page Image](https://bcdn.docswell.com/page/37KQDN1M7D.jpg)

import tensorflow as tf
# Eager Executionを有効にする
tf.compat.v1.enable_eager_execution()
# テンソルを定義
a = tf.constant([[1, 2],
[3, 4]])
b = tf.constant([[5, 6],
[7, 8]])
# テンソルの加算
c = a + b
# 結果を即時に出力
print(c)
# Output: tf.Tensor([[ 6
#
8]
[10 12]], shape=(2, 2), dtype=int32)
このように、コードが実行されるとすぐに結果が得られるため、実験的な実装やデバ
ッグが非常に効率的になる。
さらに、Eager Executionはディープラーニングにおける直感的なモデリングに役立
ち、特に複雑なモデルやデータパイプラインの試作段階での使用が推奨される。
Graph Conversion
定義や意味
Graph Conversionとは、計算グラフ（Graph）をある形式から別の形式へ変換するプ
ロセスのことを指す
特にTensorFlowなどのディープラーニングフレームワークにおいては、モデルの最適
化やデプロイメントのために計算グラフを変換することが重要となる
形式的には、グラフ G = (V , E) の変換を G′ = (V ′ , E ′ ) と表し、ここで V は頂
点の集合、E は辺の集合を表す
嚙み砕いた説明
Graph Conversionは、プログラムが内部で計算を行う方法を変えること


# Page. 17

![Page Image](https://bcdn.docswell.com/page/LJ3PRVQ275.jpg)

例えば、開発中のモデルを学習用の形式から、推論用の軽量な形式に変換することが
できる
TensorFlowでは、モデルをSavedModel形式からTFLite形式に変換し、モバイルデバ
イスで効率的に動作させることが一般的
この変換により、計算効率が向上し、メモリ使用量が減少
実際の応用例
TensorFlowで学習したモデルをTensorFlow Liteに変換し、モバイルデバイスでの推論
に使用する例
以下のコードスニペットは、TensorFlowモデルをTFLite形式に変換するプロセスを示
す
import tensorflow as tf
# Kerasモデルのロード
model = tf.keras.models.load_model(&#039;model_path&#039;)
# TFLiteConverterによるモデルの変換
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
# 変換されたモデルをファイルに保存
with open(&#039;model.tflite&#039;, &#039;wb&#039;) as f:
f.write(tflite_model)
# コメント: このコードは、KerasでトレーニングしたモデルをTFLite形式に変換し、
# ローカルストレージに保存するプロセスを示す
この変換により、モデルはモバイルデバイスや組み込みシステムでの使用に適した形
式となり、デプロイメントが容易になる
Control Flow
定義や意味
Control Flow（制御フロー）とは、プログラムの実行順序を制御するための仕組みを
指す。これには条件分岐（if文）、ループ（for文、while文）、例外処理（try-catch
文）などが含まれる。


# Page. 18

![Page Image](https://bcdn.docswell.com/page/8JDLY8967G.jpg)

プログラム内でどのコードがいつ実行されるかを制御し、効率的かつ正確な処理を実
現するための基本的な構造。
数式的には、条件分岐を評価するためのブール代数が使用される。たとえば、条件
a &gt; b が真のときに特定の処理を行うという形式。
嚙み砕いた説明
制御フローとは、プログラムがどのように動くかを決めるための道筋のこと。例え
ば、ゲームキャラクターが敵に遭遇したときに攻撃するか逃げるかを決めるのも制御
フローの一部。
もし〜ならば（if）、繰り返し（ループ）、問題があったら（例外）など、プログラ
ムの流れを決めるためのルールセット。
例えば、ゲームでプレーヤーの体力が0になるとゲームオーバーにする、といった処
理は条件分岐を用いて実現する。
実際の応用例
テンソルフロー（TensorFlow）においては、モデルのトレーニングや評価の際に制御
フローが使用される。例えば、エポックごとのトレーニングループや、トレーニング
の進捗に応じた学習率の調整など。
テンソルフローにはPythonの制御フローを利用するだけでなく、グラフモードで制御
フローを扱うための専用のオペレーションも存在する。例として tf.cond や
tf.while_loop などがある。
コードスニペット
以下に、TensorFlowを使用した簡単な例を示す。
import tensorflow as tf
# プレースホルダーを用意
x = tf.constant(3)
y = tf.constant(4)
# 条件分岐を定義（x &gt; y の場合とそれ以外）
result = tf.cond(x &gt; y, lambda: tf.add(x, y), lambda: tf.subtract(x, y))
# セッションで実行
with tf.compat.v1.Session() as sess:
print(sess.run(result))
# 出力: -1


# Page. 19

![Page Image](https://bcdn.docswell.com/page/VEP2689ZE8.jpg)

このコードでは、 tf.cond を使用して x &gt; y の条件が真の場合は x + y を、偽の場
合は x − y を計算する。
セッションを用いてテンソルフローのグラフを実行し、結果を取得する方法を示す。
このように、制御フローはプログラムがどのように実行されるかを決定し、特に複雑な処理
を効率的に行うために不可欠な要素である。
Model
定義や意味
モデルとは、入力に対して何らかの出力を生成する計算機的な枠組みを指す。特に機
械学習やディープラーニングの文脈では、モデルとはデータから学習して予測や分類
を行うアルゴリズムのこと。
モデルは通常、訓練データを用いて学習され、その後テストデータに対して性能を評
価される。モデルの性能は一般に損失関数を最小化することによって評価される。
数式的には、モデルは関数 f : X → Y として表現され、入力の集合 X に対して出
力の集合 Y を生成する。
嚙み砕いた説明
モデルは、ある特定の入力を与えると、それに対する答えや予測を返してくれる「計
算レシピ」のようなもの。
たとえば、手書きの数字画像を入力として与えると、その数字が何であるか（0〜9の
いずれか）を予測してくれる。
モデルは、たくさんの例を見て学ぶことで、未知のデータに対しても正しい出力をす
ることを目指す。
実際の応用例
TensorFlowを用いたニューラルネットワークモデルの構築と訓練の例を示す。
以下は、TensorFlowを用いて簡単な線形回帰モデルを構築し、訓練データを基に学習
するコードスニペット。


# Page. 20

![Page Image](https://bcdn.docswell.com/page/27VD3NMM7Q.jpg)

import tensorflow as tf
import numpy as np
# 訓練データ
X_train = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
y_train = np.array([2.0, 4.0, 6.0, 8.0], dtype=np.float32)
# モデルの定義
model = tf.keras.Sequential([
tf.keras.layers.Dense(units=1, input_shape=[1])
# 1つの入力を受け取り、1つの出力を返す
])
# モデルのコンパイル
model.compile(optimizer=&#039;sgd&#039;, loss=&#039;mean_squared_error&#039;)
# モデルの訓練
model.fit(X_train, y_train, epochs=500)
# モデルの予測
X_test = np.array([5.0], dtype=np.float32)
prediction = model.predict(X_test)
print(f&quot;Predicted value for input 5.0: {prediction[0][0]}&quot;)
このコードは、単純な線形関係 y = 2x を学習するモデルを構築している。
model.fit() でモデルを訓練データに基づいて学習させ、 model.predict() で新しいデ
ータに対する予測を行う。
Layer
定義や意味
レイヤー（Layer）は、ニューラルネットワークの構成要素であり、入力データに対
する変換を行う基本的な単位
各レイヤーは、入力を受け取り、重みやバイアスを用いて処理し、出力を生成する
数式で表すと、あるレイヤーの出力 y は、入力 x に対して以下のように表現される
y = f (W x + b)
ここで、W は重み行列、b はバイアスベクトル、f は活性化関数を示す


# Page. 21

![Page Image](https://bcdn.docswell.com/page/5JGY3KGXJL.jpg)

嚙み砕いた説明
レイヤーは、データを処理するためのステップのようなもの
データはレイヤーを通過するごとに変換され、新しい特徴が抽出される
たとえば、最初のレイヤーは画像のピクセルデータからエッジを検出し、次のレイヤ
ーはそのエッジを使って形を認識する
実際の応用例
レイヤーは、画像認識や音声認識といった様々なAI技術の基盤を成す
TensorFlowを用いたニューラルネットワークにおいて、レイヤーを定義し、モデルを
構築する際に用いる
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model
# モデルの定義
class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
self.conv1 = Conv2D(32, 3, activation=&#039;relu&#039;) # 畳み込みレイヤー
self.flatten = Flatten() # 平坦化レイヤー
self.d1 = Dense(128, activation=&#039;relu&#039;) # 全結合レイヤー
self.d2 = Dense(10) # 出力レイヤー
def call(self, x):
x = self.conv1(x)
# 畳み込みレイヤーを通過
x = self.flatten(x)
# 平坦化
x = self.d1(x)
# 全結合レイヤーを通過
return self.d2(x)
# 出力レイヤーで結果を取得
# モデルのインスタンス化
model = MyModel()
このコードスニペットでは、画像データを入力とするシンプルな畳み込みニューラル
ネットワーク（CNN）を定義
Conv2D レイヤーは、入力画像から特徴を抽出する役割を持つ
Flatten レイヤーは、2D出力を1Dベクトルに変換
Dense レイヤーは、ニューラルネットワークの出力を生成する


# Page. 22

![Page Image](https://bcdn.docswell.com/page/47QM5NX5EP.jpg)

Loss Function
定義や意味
損失関数（Loss Function）は、機械学習モデルの予測と実際の値との誤差を定量化す
るための関数。モデルがどれだけ正確かを測る指標として使用される
損失関数は、モデルのパラメータを最適化するための基準となり、通常はその値を最
小化するようにモデルを訓練する
定式化として、予測値を y
^、実際の値を y としたとき、一般的な損失関数の例には以
​
下がある
平均二乗誤差（Mean Squared Error, MSE）
n
1
MSE = ∑(yi − y^i )2
n i=1
​
​
​
​
​
クロスエントロピー損失（Cross-Entropy Loss）
n
1
Cross-Entropy = − ∑ [yi log(y^i ) + (1 − yi ) log(1 − y^i )]
n i=1
​
​
​
​
​
​
​
​
嚙み砕いた説明
損失関数とは、モデルがどれだけ間違っているかを数値で表すもの。大きな値ほど間
違いが多いことを示す
例えば、予測が「猫」なのに実際は「犬」だった場合、そのズレを損失関数が大きく
する。目標はこのズレを小さくすること
具体例として、テストで100点満点中90点を目指すとき、得点が80点なら「損失」は
10点。この10点をゼロに近づけるために学習する
実際の応用例
損失関数は、機械学習モデルの訓練の中核をなす部分。モデルがデータに対してどの
程度正確な予測を行っているかを示す
例えば、画像分類問題や回帰問題では、それぞれに適した損失関数を選んで用いる
TensorFlowを用いたコードスニペットで具体例を示す


# Page. 23

![Page Image](https://bcdn.docswell.com/page/KE4V9G6V71.jpg)

import tensorflow as tf
# データの準備
y_true = tf.constant([1.0, 0.0, 1.0])
# 真の値
y_pred = tf.constant([0.8, 0.2, 0.6])
# モデルの予測値
# 二乗誤差損失を計算
mse_loss = tf.keras.losses.MeanSquaredError()
mse = mse_loss(y_true, y_pred)
print(&quot;Mean Squared Error:&quot;, mse.numpy())
# バイナリクロスエントロピー損失を計算
bce_loss = tf.keras.losses.BinaryCrossentropy()
bce = bce_loss(y_true, y_pred)
print(&quot;Binary Cross-Entropy Loss:&quot;, bce.numpy())
このコードでは、 MeanSquaredError と BinaryCrossentropy を使用して損失を計算してい
る。 y_true が実際の値で、 y_pred が予測値である。これにより、モデルの精度を向上させ
るためのフィードバックを提供する。
Dataset
定義や意味
データセット(dataset)とは、機械学習モデルの訓練や評価のために使用されるデータ
の集合を指す
一般的に、データセットは訓練データ(training data)、検証データ(validation data)、お
よびテストデータ(test data)に分けられる
訓練データはモデルを学習させるために使用され、検証データはモデルのハイパーパ
ラメータの調整や過学習を防ぐために使用され、テストデータは最終的なモデルの評
価に使用される
データセットは、特徴(feature)とラベル(label)から構成されることが多い。特徴は入
力データの属性を表し、ラベルは予測対象となる値やクラスを表す
データセットは行列形式で表現されることが多く、特徴をカラム、データポイントを
行として表す。例えば、データセット X が n 個のデータポイントと m 個の特徴を
持つ場合、X は n × m の行列となる


# Page. 24

![Page Image](https://bcdn.docswell.com/page/L713KDV4EG.jpg)

嚙み砕いた説明
データセットは、モデルが学習するための「教材」のようなもの
データセットは「授業用教材」「試験問題」「模擬試験問題」のように役割が分かれ
る
機械学習では、データを使ってモデルがどれくらい正確に予測できるかを評価するた
めに、データセットを訓練、検証、テストに分けて使う
特徴はデータの「見た目」や「性質」であり、ラベルは「答え」や「結果」を指す
実際の応用例
データセットは、画像認識、自然言語処理、音声認識など、様々な機械学習タスクで
使用される
TensorFlowを用いたデータセットの利用例を以下に示す
import tensorflow as tf
# TensorFlow Datasetsを使用してデータセットをロード
(ds_train, ds_test), ds_info = tfds.load(
&#039;mnist&#039;,
# 使用するデータセット名
split=[&#039;train&#039;, &#039;test&#039;],
# 訓練とテストに分割
shuffle_files=True,
# ファイルをシャッフル
as_supervised=True,
# (入力, ラベル)形式で返す
with_info=True,
# データセットの情報も返す
)
# データセットの前処理
def normalize_img(image, label):
&quot;&quot;&quot;画像を正規化し、[0, 1]の範囲に&quot;&quot;&quot;
return tf.cast(image, tf.float32) / 255.0, label
# 訓練データセットの準備
ds_train = ds_train.map(
normalize_img, num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds_train = ds_train.cache()
# データセットをキャッシュ
ds_train = ds_train.shuffle(ds_info.splits[&#039;train&#039;].num_examples)
ds_train = ds_train.batch(128)
# バッチサイズ指定
ds_train = ds_train.prefetch(tf.data.experimental.AUTOTUNE)
# モデルの訓練に使用
model.fit(ds_train, epochs=10)
# シャッフル
# パフォーマンス向上のためのプ


# Page. 25

![Page Image](https://bcdn.docswell.com/page/G7WPDYLZE2.jpg)

この例では、TensorFlow Datasets (tfds)を使用して、MNISTデータセットをロード
し、前処理を施した後、モデルの訓練に使用している
画像データを正規化し、データセットをシャッフルし、バッチ処理を行うことでモデ
ルの学習を効率化する
Data Augmentation
定義や意味
Data Augmentationとは、既存のデータセットを用いて新たなデータを生成する手法
であり、特に機械学習やディープラーニングの文脈で用いられる
主に訓練データセットの規模を拡大し、モデルの汎化能力を向上させることを目的と
する
データの変換操作には、画像の回転、拡大縮小、左右反転、色調補正などが含まれる
数式的には、入力データ x に対して変換関数 T (x) を適用し、新しいデータ x′ を生
成する操作を指す
x′ = T (x)
嚙み砕いた説明
Data Augmentationは、機械学習モデルがより多様なデータに対して学習できるよう
にするためのテクニック
例えば、猫の画像が1枚しかない場合でも、この画像を回転させたり、色を変えたり
することで、異なる猫の画像をたくさん生成できる
これにより、モデルがその猫を様々な角度や色合いでも認識できるようになる
実際の応用例
Data Augmentationは特に画像分類タスクで多用され、訓練データの不足を補う手段
として重要
TensorFlowでは、 tf.keras.preprocessing.image.ImageDataGenerator を使用して簡単
にData Augmentationを実装可能


# Page. 26

![Page Image](https://bcdn.docswell.com/page/4JZKGXMLJ3.jpg)

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# 画像データ拡張を設定
datagen = ImageDataGenerator(
rotation_range=40,
# 角度をランダムに回転
width_shift_range=0.2,
# 水平方向にランダムにシフト
height_shift_range=0.2, # 垂直方向にランダムにシフト
shear_range=0.2,
# シアー変換
zoom_range=0.2,
# ズーム
horizontal_flip=True,
# 水平方向にランダムに反転
fill_mode=&#039;nearest&#039;
# 埋め込みモード
)
# 画像データを生成
train_datagen = datagen.flow_from_directory(
&#039;data/train&#039;,
# 訓練データのディレクトリ
target_size=(150, 150), # 画像サイズ
batch_size=32,
class_mode=&#039;binary&#039;
)
このコードスニペットでは、ディレクトリに存在する画像データに対して様々な変換
を適用し、新しい訓練データを生成する
これにより、モデルのトレーニングに使用するデータの多様性を向上させ、過学習を
防ぐ効果を持つ
Graph Execution
定義や意味
Graph Executionはプログラムの実行モデルの一つで、特にTensorFlowなどの機械学
習フレームワークで用いられる概念
プログラムをグラフ構造として表現し、このグラフを実行することで計算を行う
グラフはノードとエッジから構成され、ノードは計算操作や変数を表し、エッジはデ
ータの流れを表す
グラフ構造により、計算の最適化や並列化が可能になる
例えば、グラフには次のような単純な形式がある


# Page. 27

![Page Image](https://bcdn.docswell.com/page/YE6QY4NMEV.jpg)

y =a×x+b
ここで、y は出力、x は入力、a と b は定数である
嚙み砕いた説明
Graph Executionは、計算を行う際にその計算を一連の操作としてグラフに変換し、
そのグラフを実行するという考え方
直列的に一行ずつコードを実行するのではなく、データの流れをグラフで表し、その
グラフを一括で最適化・実行する
これにより、計算を効率化したり、複雑な計算を並列化したりできる
例えば、料理のレシピを考えると、食材の準備や調理を一つ一つ順に行うのではな
く、同時にできることは同時に進めるように計画するイメージ
実際の応用例
TensorFlowでのニューラルネットワークのトレーニングや推論において、Graph
Executionが広く使用される
TensorFlowでは、グラフを構築し、それをセッションで実行することができる
以下にTensorFlowを用いた単純なGraph Executionの例を示す
import tensorflow as tf
# 定数（ノード）を定義
a = tf.constant(2, name=&quot;a&quot;)
b = tf.constant(3, name=&quot;b&quot;)
# 計算グラフを構築
c = tf.add(a, b, name=&quot;add&quot;)
# グラフを実行するためのセッションを開始
with tf.compat.v1.Session() as sess:
# グラフを実行し、結果を取得
result = sess.run(c)
print(&quot;Result of the addition: &quot;, result)
# 出力: Result of the addition:
5
この例では、まず定数ノード a と b を定義し、それらを加算するノード c をグラフと
して構築
tf.compat.v1.Session() を用いてグラフを実行し、結果を取得する


# Page. 28

![Page Image](https://bcdn.docswell.com/page/GE5RGQ5QJ4.jpg)

このように、Graph Executionを用いることで、計算を効率的に行うことが可能にな
る
Performance Optimization
定義や意味
パフォーマンス最適化とは、ソフトウェアやゲームの実行速度や効率を向上させるた
めの技術や手法の総称。特に計算量の多い操作を効率的に処理するために、アルゴリ
ズムの改善、ハードウェアの適切な利用、リソースの管理などを通じてパフォーマン
スを向上させることを目的とする。
数式的には、プログラムの実行時間を T (n) とし、入力サイズを n としたとき、
T (n) を最小化することが目標となる。最適化の指標として、時間計算量のオーダー
である O(f (n)) を用いる。
嚙み砕いた説明
パフォーマンス最適化は、プログラムがより速く動くように工夫すること。例えば、
ゲームでキャラクターが動くのが遅いと感じたら、その動きを速くするためにプログ
ラムを調整する。
具体的には、リソース（CPU、メモリ、グラフィックス）を無駄なく使うようにす
る。例えば、同じ計算を毎回やり直すのではなく、一度計算した結果を記憶して次回
から再利用する方法（メモ化）などがある。
実際の応用例
TensorFlowを利用したディープラーニングモデルのトレーニングにおいて、GPUを活
用して計算を並列化することでトレーニング時間を短縮することが挙げられる。
以下は、TensorFlowを使用したニューラルネットワークのトレーニングをGPU上で最
適化する例。


# Page. 29

![Page Image](https://bcdn.docswell.com/page/972DYPNW7R.jpg)

import tensorflow as tf
# デバイスを明示的に指定し、GPUでの演算を確認
with tf.device(&#039;/GPU:0&#039;):
# モデルの作成
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(128, activation=&#039;relu&#039;, input_shape=(784,)),
tf.keras.layers.Dense(10, activation=&#039;softmax&#039;)
])
# モデルのコンパイル
model.compile(optimizer=&#039;adam&#039;,
loss=&#039;sparse_categorical_crossentropy&#039;,
metrics=[&#039;accuracy&#039;])
# データセットのロードと前処理
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# モデルのトレーニング
model.fit(x_train, y_train, epochs=5)
# モデルの評価
model.evaluate(x_test, y_test)
上記のコードでは、 tf.device(&#039;/GPU:0&#039;) と指定することで、TensorFlowが使用可能
なGPUを活用して計算を行うようにしている。これにより、CPUのみを使用する場合
よりも大幅に計算速度が向上し、トレーニング時間を短縮できる。
MirroredStrategy
定義や意味
MirroredStrategyは、TensorFlowにおける分散トレーニングのための戦略の一つ。複
数のデバイス（CPUやGPU）にモデルのコピーを作成し、各デバイスで並行して計算
を行い、勾配を同期することで効率的にトレーニングを行う手法。
各デバイスは独立して計算を行うが、勾配の更新時に同期する。これにより、各デバ
イスが計算した勾配の平均を用いてモデルを更新する。


# Page. 30

![Page Image](https://bcdn.docswell.com/page/DJY2G5P9JM.jpg)

数式で表すと、各デバイスiでの損失関数Li (θ)に対する勾配∇Li (θ)を計算し、全デ
​
​
バイスでの勾配の平均を取ってモデルパラメータθ を更新する:
N
1
θ = θ − η ∑ ∇Li (θ)
N
​
​
i=1
ここで、N はデバイスの数、η は学習率を示す。
嚙み砕いた説明
MirroredStrategyは、同じモデルを複数のデバイスで同時に動かし、それぞれが独自
に計算した結果を統合することで、より速く効率的にモデルをトレーニングする手
法。
各デバイスは同じデータの異なる部分を処理し、それぞれの結果をまとめることで全
体としての学習を進める。これにより、単一のデバイスで学習するよりも短い時間で
トレーニングが完了する。
例えば、画像認識のモデルをトレーニングする際に、異なるGPUに異なるバッチの画
像を割り当て、それぞれで計算した誤差を平均してモデルを更新する。
実際の応用例
MirroredStrategyは、深層学習モデルのトレーニング時間を短縮するために、特に大
規模なデータセットや複雑なモデルに対して広く使用されている。
以下のコードスニペットは、TensorFlowでMirroredStrategyを使用してモデルをトレ
ーニングする方法を示す。


# Page. 31

![Page Image](https://bcdn.docswell.com/page/V7N8GN5DE8.jpg)

import tensorflow as tf
# MirroredStrategyオブジェクトを作成
strategy = tf.distribute.MirroredStrategy()
# ストラテジーのスコープ内でモデルを構築
with strategy.scope():
# モデルの構築
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(64, activation=&#039;relu&#039;, input_shape=(784,)),
tf.keras.layers.Dense(10, activation=&#039;softmax&#039;)
])
# モデルのコンパイル
model.compile(loss=&#039;sparse_categorical_crossentropy&#039;,
optimizer=tf.keras.optimizers.Adam(),
metrics=[&#039;accuracy&#039;])
# データの準備
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_
train_images = train_images.reshape(-1, 784).astype(&#039;float32&#039;) / 255.0
test_images = test_images.reshape(-1, 784).astype(&#039;float32&#039;) / 255.0
# モデルのトレーニング
model.fit(train_images, train_labels, epochs=5, batch_size=64)
この例では、MNISTデータセットを用いて簡単なニューラルネットワークモデルをト
レーニングしている。MirroredStrategyを使用することで、利用可能なすべてのGPU
を活用し、トレーニングを並列処理してより高速に実行する。
TPUStrategy
定義や意味
TPUStrategyは、TensorFlowにおける分散学習のための戦略の一つ。特に、Googleの
Tensor Processing Unit (TPU)を用いた計算を効率的に行うための戦略を提供する。
TPUStrategyを使用することで、モデルのトレーニングをTPU上で並列に行うことが
可能となり、計算速度が大幅に向上する。これは、特に大規模なデータセットや複雑
なモデルにおいて有効。


# Page. 32

![Page Image](https://bcdn.docswell.com/page/YJ9KWRY8J3.jpg)

TPUStrategyは、TensorFlowの tf.distribute.Strategy APIの一部であり、コードを
ほぼ変更せずにCPUやGPUからTPUに切り替えることが可能。
嚙み砕いた説明
TPUStrategyは、TensorFlowを使ってモデルをトレーニングする際に、Googleが開発
した専用のハードウェアTPUを使ってより速く効率的に計算を行うための方法。
通常、CPUやGPUを使って行う計算をTPUに切り替えることで、特に大量のデータや
複雑なモデルを扱う際に、計算時間を大幅に短縮できる。
TPUStrategyを使うことで、複数のTPUコアを使って同時に計算を行うことができ、
これにより学習が高速化する。
実際の応用例
TPUStrategyは、自然言語処理や画像認識、音声認識など、大規模なデータを使った
機械学習モデルのトレーニングにおいて広く利用されている。
TensorFlowでのTPUStrategyの基本的な使用例を示すコードスニペットを以下に示
す。


# Page. 33

![Page Image](https://bcdn.docswell.com/page/GJ8RNW6Z7D.jpg)

import tensorflow as tf
# TPUStrategyを作成
resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu=&#039;&#039;)
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.experimental.TPUStrategy(resolver)
# strategy.scope()を使ってモデルを定義
with strategy.scope():
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(128, activation=&#039;relu&#039;, input_shape=(784,)),
tf.keras.layers.Dense(10, activation=&#039;softmax&#039;)
])
model.compile(
optimizer=&#039;adam&#039;,
loss=&#039;sparse_categorical_crossentropy&#039;,
metrics=[&#039;accuracy&#039;]
)
# データセットの準備
mnist_dataset = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist_dataset.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# モデルのトレーニング
model.fit(x_train, y_train, epochs=5)
このコードは、TPUを使用してMNISTデータセットを分類するための単純なニューラ
ルネットワークモデルを定義し、トレーニングする例を示す。
strategy.scope() を用いることで、モデルとオプティマイザがTPU上で実行されるよ
うに設定される。
Sequential Model
定義や意味
Sequential Modelは、深層学習におけるニューラルネットワークの一種で、層が一列
に並んだ単純なアーキテクチャを持つモデル。各層が順次に前の層の出力を次の層の
入力として受け取る。


# Page. 34

![Page Image](https://bcdn.docswell.com/page/LJLKPN917R.jpg)

数学的には、各層の出力をh(l) とし、入力をx、重みをW (l) 、バイアスをb(l) 、活性化
関数をf (l) とすると、層lの出力は以下のように表される。
h(l) = f (l) (W (l) h(l−1) + b(l) )
ここで、h(0) = xとする。
嚙み砕いた説明
Sequential Modelは、いわば積み木のようなもので、各層を順番に積み重ねることで
ネットワークを構築する。例えば、入力層にデータを入れ、次に隠れ層を通し、最終
的に出力層から結果を得るような流れ。
各層は、初めの入力を受けて、何らかの変換を行い、次の層にその結果を渡してい
く。これにより、徐々にデータの複雑な特徴を抽出していく。
実際の応用例
Sequential Modelは、画像認識や自然言語処理、音声認識など、様々なディープラー
ニングのタスクで応用されている。
TensorFlowのKeras APIを用いると、簡単にSequential Modelを構築することができ
る。以下にその例を示す。


# Page. 35

![Page Image](https://bcdn.docswell.com/page/47M24XZ57W.jpg)

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Sequential Modelのインスタンスを作成
model = Sequential()
# 入力層を追加（入力の形状を指定）
model.add(Dense(units=64, activation=&#039;relu&#039;, input_shape=(100,)))
# 隠れ層を追加
model.add(Dense(units=64, activation=&#039;relu&#039;))
# 出力層を追加
model.add(Dense(units=10, activation=&#039;softmax&#039;))
# モデルのコンパイル
model.compile(optimizer=&#039;adam&#039;,
loss=&#039;categorical_crossentropy&#039;,
metrics=[&#039;accuracy&#039;])
# モデルの構造を表示
model.summary()
# コメントアウト:
# - Dense層は全結合層であり、各ユニットは前の層すべてのユニットに接続される。
# - &#039;relu&#039;は活性化関数で、非線形変換を行う。
# - &#039;softmax&#039;は出力が確率として解釈されるようにするために用いる。
# - モデルのコンパイルでは、最適化アルゴリズムと損失関数を指定。
このコードスニペットは、単純な全結合ネットワークを表し、入力として100次元の
データを受け取り、10クラスの分類を行う例。
Functional API
定義や意味
Functional APIは、TensorFlowの高レベルAPIであるKerasにおいて、ニューラルネッ
トワークを柔軟に構築するためのモデル定義方法の一つ


# Page. 36

![Page Image](https://bcdn.docswell.com/page/P7RMWN6ZJ9.jpg)

Sequential APIが単純な積み重ねでモデルを作成するのに対し、Functional APIは複雑
なネットワーク構造、分岐やマージ、共有レイヤーなどを容易に実現する
Functional APIは、モデルの入力と出力を明示的に定義し、レイヤーを関数として扱
うことで、ネットワークのグラフ構造を定義する
Functional APIを用いることで、任意のDAG（Directed Acyclic Graph：有向非巡回グ
ラフ）としてモデルを構築可能
嚙み砕いた説明
Functional APIは、レゴのブロックのように、ネットワークの各部分（レイヤー）を
組み合わせて複雑なモデルを作成できる
レイヤーを関数のように扱い、入力を渡すと出力が得られる仕組み
例えば、画像認識のための畳み込み層と全結合層を組み合わせて、その間に特殊な処
理を挟むようなネットワークを構築できる
グラフ構造でモデルを定義するため、ネットワークの一部を再利用したり、複数の入
力や出力を持つモデルを簡単に作成可能
実際の応用例
画像分類、自然言語処理、時系列分析などの複雑なモデル構築に利用
例えば、入力画像とメタデータ（数値データ）を同時に使用するマルチモーダルモデ
ルを構築する際に便利
以下に、Functional APIを使った簡単なモデルの例を示す。この例では、2つの入力を持つネ
ットワークを構築し、それぞれの入力を処理した後に結合して出力する。


# Page. 37

![Page Image](https://bcdn.docswell.com/page/PJXVPNM1EX.jpg)

import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, concatenate
from tensorflow.keras.models import Model
# 入力テンソルの定義
input_a = Input(shape=(64,), name=&#039;input_a&#039;)
input_b = Input(shape=(32,), name=&#039;input_b&#039;)
# 各入力に対する処理
x = Dense(128, activation=&#039;relu&#039;)(input_a)
y = Dense(64, activation=&#039;relu&#039;)(input_b)
# 結合
combined = concatenate([x, y])
# 出力層
output = Dense(1, activation=&#039;sigmoid&#039;)(combined)
# モデルの定義
model = Model(inputs=[input_a, input_b], outputs=output)
# モデルのコンパイル
model.compile(optimizer=&#039;adam&#039;, loss=&#039;binary_crossentropy&#039;, metrics=[&#039;accuracy&#039;])
# モデルの概要を表示
model.summary()
# コメントアウト:
# - input_a と input_b はそれぞれ異なる形状の入力データを受け取る
# - concatenate により、2つの入力を結合して1つのベクトルにする
# - 最終的な出力は1つのニューロンからなるシグモイド活性化関数を持つ
このコードスニペットでは、Functional APIを使用して、2つの異なる入力を持つモデルを構
築し、各入力に対して異なる処理を行い、それらを結合して最終出力を得る。Functional API
の強みである複雑な構造のモデルを簡単に作成できる様子が示されている。


