---
title: CV_Torchvision
tags: 
author: [kokuren](https://convert.docswell.com/user/kokuren333)
site: [Docswell](https://www.docswell.com/)
thumbnail: https://bcdn.docswell.com/page/4JZKGPZ3J3.jpg?width=480
description: CV_Torchvision by kokuren
published: November 28, 24
canonical: https://convert.docswell.com/s/kokuren333/5DNWDL-2024-11-28-201927
---
# Page. 1

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

Torchvision
Datasets
Transforms
ImageNet
CIFAR-10
COCO
MNIST
Preprocessing
Augmentation
Annotation
Digit Recognition
Compose
ToTensor
Normalize
Models
RandomCrop
RandomHorizontalFlip
ResNet
VGG
AlexNet
Utils
MobileNet
Inception
DataLoader
make_grid
save_image
Torchvision
定義や意味
Torchvisionは、PyTorchディープラーニングライブラリの一部であり、特にコンピュータビジョンタスクのためのデータセ
ット、モデル、および画像変換のための便利なツールセットを提供する。
具体的には、Torchvisionは事前トレーニング済みモデル、一般的なデータセットのダウンロードと読み込み、画像データ
の変換や前処理を簡単にするための機能を含んでいる。
嚙み砕いた説明
Torchvisionは、画像処理を伴うディープラーニングプロジェクトを行う際に非常に便利なツールである。たとえば、画像
を簡単に読み込んで変換したり、既に訓練済みのモデルを利用して新しい画像に対する予測を行ったりすることができる。
具体例として、画像を学習用にサイズを変更したり、ランダムに反転させたりする前処理が簡単にできる。
実際の応用例
Torchvisionは様々なコンピュータビジョンの応用で使用される。以下は、Torchvisionを用いて事前トレーニング済みの
ResNetモデルを使い、画像分類を行う例である。


# Page. 2

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

import torch
import torchvision.transforms as transforms
from torchvision import models
from PIL import Image
# 事前トレーニング済みのResNet50モデルをロード
model = models.resnet50(pretrained=True)
model.eval()
# 推論モードに切り替え
# 画像の前処理を定義
preprocess = transforms.Compose([
transforms.Resize(256),
# 画像を256x256にリサイズ
transforms.CenterCrop(224),
transforms.ToTensor(),
# 中心を224x224にクロップ
# テンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# 正規化
])
# 画像を読み込む
img = Image.open(&quot;path/to/your/image.jpg&quot;)
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0)
# バッチ次元を追加
# 予測を実行
out = model(batch_t)
_, index = torch.max(out, 1)
# 結果を取得
print(&quot;Predicted class index:&quot;, index.item())
上記のコードでは、Torchvisionの transforms を使用して画像の前処理を行い、事前トレーニング済みのResNet50モデルを
使用して画像のクラスを予測している。
これは、例えば画像分類タスクにおいて、画像が犬または猫であるかを判別するような場合に応用できる。
Datasets
定義や意味
データセットは、特定のタスクや目的に応じたデータの集合を指す。これは、機械学習モデルの訓練や評価、テストに使用
される。一般に、データセットは特徴（features）とその特徴に関連するラベル（labels）から構成される。データセット
は通常、訓練用（training set）、検証用（validation set）、テスト用（test set）の3つに分割される。
数式的に、データセットは次のように表現されることが多い：
訓練データセット： Dtrain = {(x1 , y1 ), (x2 , y2 ), … , (xn , yn )}
​
​
​
​
​
​
​
ここで xi は入力データ、yi はラベル。
​
​
嚙み砕いた説明
データセットとは、機械学習やAIモデルを教えるためのデータの集まりのこと。例えば、猫と犬を識別するAIを作りたい場
合、猫や犬の画像をたくさん集めて、それぞれ「猫」「犬」というラベルを付ける。これがデータセットになる。データセ
ットは、モデルが「学ぶ」ために必要な教材のようなもの。
実際の応用例
データセットは、コンピュータビジョン分野で画像分類や物体検出、セグメンテーションのタスクに広く使用されている。
特に、TorchvisionはPyTorchのライブラリで、画像データセットの読み込み、前処理、データ拡張を簡単に行うためのツー
ルを提供している。以下にTorchvisionを用いた例を示す。


# Page. 3

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

import torch
from torchvision import datasets, transforms
# データ拡張と前処理を定義
transform = transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor()
])
# CIFAR-10の訓練データセットをダウンロードし、前処理を適用
train_dataset = datasets.CIFAR10(root=&#039;./data&#039;, train=True, download=True, transform=transform)
# データローダーを作成
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
# データセットからバッチを取得する例
data_iter = iter(train_loader)
images, labels = data_iter.next()
print(images.shape)
# 画像のテンソルサイズを出力
print(labels.shape)
# ラベルのテンソルサイズを出力
上記のコードスニペットでは、Torchvisionライブラリを使ってCIFAR-10データセットをダウンロードし、画像を128x128
にリサイズした後、テンソルに変換している。データローダーを用いて、データセットをバッチ単位で処理することが可
能。
Transforms
定義や意味
Transformsとは、データを前処理するための操作や関数を指す。特に機械学習や深層学習の文脈においては、データセッ
トの前処理やデータ拡張のために用いられる。
具体的には、画像データのリサイズ、回転、正規化、ランダムクロッピングなどの操作が含まれる。
Transformsを適用することで、モデルの訓練におけるデータの多様性を増やし、過学習を防ぐ効果がある。
嚙み砕いた説明
Transformsは、データをモデルに入力する前に「変換」する方法と考えることができる。例えば、写真を撮ったときに、
サイズを変更したり、色合いを調整したりすることがあるが、これがTransformの例。
ディープラーニングでは、こうした変換を用いて、モデルがより多くの状況に適用可能になるようにする。これには、画像
を左右反転させたり、ランダムに切り取ったりすることが含まれる。これにより、モデルが様々なバリエーションに対して
強くなる。
実際の応用例
PyTorchのライブラリであるtorchvisionでは、画像データに対する様々なTransformsを提供している。
例として、画像のリサイズと正規化を行うTransformの利用法を示す。


# Page. 4

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

from torchvision import transforms
# 画像をリサイズし、正規化するTransformの定義
transform = transforms.Compose([
transforms.Resize((256, 256)),
# 画像を256x256にリサイズ
transforms.ToTensor(),
# 画像をテンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# 正規化
])
# 使用例：データセットにTransformを適用
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
# ImageFolderを用いたデータセットの定義
dataset = ImageFolder(root=&#039;path/to/data&#039;, transform=transform)
# DataLoaderを用いてデータセットをバッチ処理
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
# データを反復処理
for images, labels in dataloader:
# modelsへの入力などの処理を行う
pass
このコードスニペットでは、画像を256x256にリサイズし、テンソルに変換した後、通常の正規化を行う一連のTransform
を定義している。
このTransformは、 ImageFolder によって読み込まれた画像データセットに適用され、 DataLoader を用いてバッチ処理を行
う。
Models
定義や意味
モデルとは、機械学習やディープラーニングにおけるデータとその出力との関係を表現するための数学的構造。特に、学習
データを用いてパラメータを最適化し、新しいデータに対する予測や分類を行うためのもの。
モデルの定義は主に以下の式で表されることが多い：
y = f (x; θ)
ここで、y は出力、x は入力データ、θ はモデルのパラメータセット、f はモデルの関数形を表す。
Torchvisionにおけるモデルは、主に画像処理を目的としたディープラーニングモデルを指し、事前学習済みのものも多く
提供されている。
嚙み砕いた説明
モデルは、何かを予測したり、分類するために使うルールの集合のようなもの。データを入力すると、それに基づいて何か
しらの結果を出力する。
例えば、画像を入力として、そこに写っているものが猫か犬かを判別するためのルールをモデルが持っている。
Torchvisionは、画像処理に特化したライブラリで、画像を扱うための様々なツールや、既に訓練されたモデルを提供して
いる。


# Page. 5

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

実際の応用例
画像認識タスクで、画像を入力として、その画像に含まれる物体を認識するために使われる。
Torchvisionを使用した画像分類のコード例：
import torchvision.models as models
import torch
from torchvision import transforms
from PIL import Image
# 事前学習済みのResNet18モデルをロード
model = models.resnet18(pretrained=True)
model.eval()
# 評価モードに設定
# 画像の前処理
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# 画像を開く
img = Image.open(&quot;path/to/image.jpg&quot;)
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0)
# 画像をモデルに入力し、予測を取得
with torch.no_grad():
out = model(batch_t)
# 出力をソフトマックスに変換し、確率を取得
probabilities = torch.nn.functional.softmax(out[0], dim=0)
# 結果を表示
print(probabilities)
この例では、TorchvisionのResNet18モデルを用いて、指定された画像が何であるかを分類する。また、モデルの出力をソ
フトマックス関数で変換し、各クラスに対する確率を得ることができる。
Utils
定義や意味
&quot;Utils&quot; は &quot;utilities&quot; の略称で、プログラミングやゲーム制作において、特定のタスクや操作を簡単にするための補助的な関
数やクラスの集合を指す
これらのユーティリティ関数は、一般的なタスクを再利用可能な形でカプセル化し、コードの重複を減らし、開発効率を向
上させる
具体的な例として、データの前処理、画像の変換、ファイルの読み書き、ログの生成などが挙げられる
嚙み砕いた説明
&quot;Utils&quot; は、プログラムの中で何度も繰り返し使われる便利な道具箱のようなもの
例えば、画像を読み込んでサイズを変えるといった操作を、毎回自分で書くのは面倒だが、Utilsに入れておけば、いつでも
簡単に使えるようになる


# Page. 6

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

これは、開発者が複雑な問題に集中できるようにするための手助け
実際の応用例
画像処理ライブラリであるTorchvisionでは、データセットを扱う際の共通の操作を提供する
例えば、Torchvisionの transforms モジュールは、画像データの変換や前処理を行うためのユーティリティの一部として機
能する
以下に、Torchvisionを利用した画像の前処理ユーティリティの例を示す：
import torchvision.transforms as transforms
from PIL import Image
# 画像の前処理を定義
preprocess = transforms.Compose([
transforms.Resize(256),
# 画像のサイズを256x256に変更
transforms.CenterCrop(224),
transforms.ToTensor(),
# 中央を224x224でクロップ
# テンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# 正規化
])
# 画像を読み込む
input_image = Image.open(&quot;path/to/image.jpg&quot;)
# 前処理を適用
input_tensor = preprocess(input_image)
このコードでは、画像データをモデルに入力するための一連の前処理を行う
transforms.Compose を使って一連の変換を定義し、 Resize や Normalize といった基本的な操作をUtilとして活用している
ImageNet
定義や意味
ImageNetは、画像認識ソフトウェアの開発と評価に用いられる大規模な画像データセット
約1,400万枚の画像が含まれており、それぞれの画像はWordNet階層に基づく1000以上のカテゴリにラベル付けされている
ImageNetの目的は、コンピュータービジョンの研究を促進し、画像認識技術を向上させること
ImageNet Large Scale Visual Recognition Challenge (ILSVRC)は、毎年開催されるコンペティションで、これにより画像認
識技術の発展が促進されている
嚙み砕いた説明
ImageNetは、猫や犬、車など、さまざまな物体の画像がたくさん集まった図鑑のようなもの
各画像には、「これは猫です」「これは車です」といったラベルが付けられている
コンピュータがこの図鑑を使って、画像を見たときに何が写っているのかを判断する能力を学習するために使われる
この大規模なデータセットにより、AIがより正確に画像を認識できるようになる
実際の応用例
ImageNetは、ディープラーニング技術の進歩に大きく寄与しており、特に畳み込みニューラルネットワーク（CNN）の発
展において重要な役割を果たしている
Torchvisionは、PyTorchのライブラリであり、ImageNetを含む多くの標準的なデータセットを簡単に利用できるようにして
いる


# Page. 7

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

以下に、Torchvisionを用いてImageNetデータセットをロードする例を示す
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
# データ変換の定義
transform = transforms.Compose([
transforms.Resize(256),
# 画像を256x256にリサイズ
transforms.CenterCrop(224),
transforms.ToTensor(),
# 中央部分を224x224にクロップ
# 画像をテンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# 正規化
])
# ImageNetデータセットのロード
imagenet_data = datasets.ImageNet(&#039;/path/to/imagenet_root&#039;, split=&#039;train&#039;, transform=transform)
# DataLoaderの作成
data_loader = DataLoader(imagenet_data, batch_size=32, shuffle=True)
# データを使用する例
for images, labels in data_loader:
# ここでモデルへの入力に使用する
pass
上記のコードスニペットは、PyTorchとTorchvisionを使用してImageNetデータセットをロードし、データを前処理してモデ
ルに入力するための準備を行う方法を示している
このようにして、研究者や開発者はImageNetを利用して画像認識モデルをトレーニングし、評価することができる
CIFAR-10
定義や意味
CIFAR-10とは、Canadian Institute for Advanced Researchが提供する画像データセットの一つで、特に機械学習やディー
プラーニングの研究において広く使用される。
このデータセットは、10種類の異なるクラスに分類された計60,000枚のカラー画像で構成される。各クラスには6,000枚の
画像が用意されており、トレーニング用に50,000枚、テスト用に10,000枚の画像が含まれている。
各画像はサイズが32x32ピクセルであり、RGBチャンネルを持つため、データの形状は(3, 32, 32)となる。
嚙み砕いた説明
CIFAR-10は、画像認識の機械学習モデルを訓練するための小さな画像データセット。10種類のクラス（例: 飛行機、自動
車、鳥、猫、鹿、犬、カエル、馬、船、トラック）があり、それぞれのクラスに数千枚の画像が含まれる。
データセットは小さな正方形の画像で構成されており、これを使ってアルゴリズムが画像内の物体をどのように認識するか
を学ぶ。
実際の応用例
CIFAR-10は、ディープラーニングモデル、特に畳み込みニューラルネットワーク（CNN）のトレーニングと評価に使用さ
れる。
研究や教育で、モデルの性能を比較するための標準的なベンチマークとして用いられる。
以下は、PyTorchの torchvision ライブラリを使用してCIFAR-10データセットをロードし、基本的なデータ前処理を行う
例。


# Page. 8

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

import torch
import torchvision
import torchvision.transforms as transforms
# データ変換の定義
transform = transforms.Compose([
transforms.ToTensor(),
# 画像をテンソルに変換
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# 平均と標準偏差で正規化
])
# CIFAR-10のトレーニングデータセットをロード
trainset = torchvision.datasets.CIFAR10(root=&#039;./data&#039;, train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
# CIFAR-10のテストデータセットをロード
testset = torchvision.datasets.CIFAR10(root=&#039;./data&#039;, train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
# クラスの名前
classes = (&#039;plane&#039;, &#039;car&#039;, &#039;bird&#039;, &#039;cat&#039;,
&#039;deer&#039;, &#039;dog&#039;, &#039;frog&#039;, &#039;horse&#039;, &#039;ship&#039;, &#039;truck&#039;)
# データのサンプルを取得
dataiter = iter(trainloader)
images, labels = next(dataiter)
# 画像とラベルを印刷
print(&#039; &#039;.join(f&#039;{classes[labels[j]]:5s}&#039; for j in range(4)))
このコードスニペットでは、CIFAR-10データセットをダウンロードし、トレーニングおよびテスト用のデータローダーを
設定する。データはテンソルに変換され、平均0.5、標準偏差0.5で正規化されている。
COCO
定義や意味
COCO（Common Objects in Context）は、画像認識と物体検出のための大規模なデータセットの一つ。Microsoftが提供す
るもので、複数のカテゴリにわたる多様な日常物体の画像を含む。COCOデータセットは画像にアノテーションが施されて
おり、物体検出、セグメンテーション、キャプション生成などのタスクに用いられる。
COCOのデータセットは、80の物体カテゴリと、約33万枚の画像が含まれ、各画像には複数の物体が描かれているのが特
徴。データセットは、物体の境界ボックスやセマンティックセグメンテーションマスク、そしてキャプションといったアノ
テーションを提供する。
例えば、物体検出タスクにおいては、各物体の位置とカテゴリラベルを含むアノテーションが提供される。これは数式で表
すと、画像 I 内の物体の集合 O = {(b1 , c1 ), (b2 , c2 ), … , (bn , cn )} であり、各ペア (bi , ci ) は物体の境界ボックス bi と
カテゴリラベル ci を示す。
​
​
​
​
​
​
​
​
​
​
嚙み砕いた説明
COCOは、画像に写っている物体を特定のカテゴリに分類し、それらの位置を特定するために使われるデータセット。たと
えば、画像に犬や猫、車などが写っている場合、それらがどこにあり、何であるかを識別するために利用される。


# Page. 9

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

COCOデータセットは、研究者や開発者がAIモデルを訓練するための重要なリソースで、特に画像認識や物体検出の分野で
多く使われている。日常的なシーンに多くのオブジェクトが含まれているため、現実世界に近い条件でモデルを訓練でき
る。
実際の応用例
COCOデータセットは、物体検出、画像セグメンテーション、画像キャプション生成のためのモデルの訓練と評価に広く使
用されている。例えば、Mask R-CNNやYOLOなどの物体検出アルゴリズムはCOCOデータセットを用いて評価されること
が多い。
PyTorchのライブラリであるTorchvisionは、COCOデータセットを簡単に活用できるようにするためのデータ読み込みユー
ティリティを提供している。以下に、Torchvisionを用いてCOCOデータセットを読み込む例を示す。
import torchvision
from torchvision.datasets import CocoDetection
# COCOデータセットのパスを指定
data_dir = &#039;/path/to/coco&#039;
ann_file = &#039;/path/to/annotations/instances_train2017.json&#039;
# COCOデータセットの読み込み
coco_dataset = CocoDetection(root=data_dir, annFile=ann_file)
# データセットから画像とアノテーションを取得
image, annotation = coco_dataset[0]
# 画像とアノテーションを表示
print(&quot;Image size:&quot;, image.size)
print(&quot;Annotations:&quot;, annotation)
このコードスニペットでは、Torchvisionの CocoDetection クラスを用いて、COCOデータセットを読み込み、最初の画像と
そのアノテーション情報を取得している。このようにして、COCOデータセットを使ったモデルの訓練や評価を行うことが
できる。
MNIST
定義や意味
MNIST（Modified National Institute of Standards and Technology）は、手書き数字の画像データセットであり、機械学習の
トレーニングやテストに広く使用されている
データセットは、0から9までの数字の28x28ピクセルのグレースケール画像で構成され、60,000枚のトレーニングデータと
10,000枚のテストデータが含まれている
各画像は784（28 × 28）のピクセル値からなるベクトルとして表現される
嚙み砕いた説明
MNISTは、手書き数字認識のための「Hello, World!」的なデータセットで、画像認識の基礎を学ぶためのよい出発点となる
それぞれの画像は、28x28の小さな正方形で、色濃度は0から255の範囲となる
このデータセットを用いることで、機械学習モデルは数字を自動的に認識する方法を学習できる
実際の応用例
MNISTはディープラーニングやニューラルネットワークの基礎を学ぶための教材としてよく用いられる


# Page. 10

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

下記のコードスニペットは、PyTorchのtorchvisionライブラリを使用してMNISTデータセットをロードし、データの先頭部
分を表示する例
import torch
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
# MNISTデータセットの変換（テンソルへの変換）
transform = transforms.Compose([transforms.ToTensor()])
# データセットのダウンロードとロード
train_dataset = datasets.MNIST(root=&#039;./data&#039;, train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root=&#039;./data&#039;, train=False, download=True, transform=transform)
# データローダーの作成
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
# サンプルデータを取得して、表示
examples = iter(train_loader)
example_data, example_targets = examples.next()
fig, ax = plt.subplots(nrows=1, ncols=6, figsize=(15, 4))
for i in range(6):
ax[i].imshow(example_data[i][0], cmap=&#039;gray&#039;)
ax[i].set_title(f&#039;Label: {example_targets[i]}&#039;)
ax[i].axis(&#039;off&#039;)
plt.show()
上記のコードは、MNISTデータセットをトレーニングセットとしてロードし、データの一部を表示するためのもの
torchvision.datasets.MNIST を用いてデータセットを取得し、 transforms でデータをテンソル形式に変換している
DataLoader はデータをバッチサイズで分割し、反復可能なオブジェクトとして提供
Compose
定義や意味
Composeは、複数の画像変換（transform）を連続的に適用するための手法を提供する。特に機械学習やディープラーニン
グの分野で、データ前処理の一環として広く使用される。
PyTorchのサブライブラリであるTorchvisionにおいて、 torchvision.transforms.Compose は、複数の変換をリストとして受
け取り、それらを順番に適用するためのクラス。これにより、データの前処理フローを簡潔に定義できる。
数式としては、与えられた入力データ x に対して複数の変換 T1 , T2 , … , Tn を適用する操作を次のように表す：
​
​
​
T (x) = Tn (Tn−1 (… T2 (T1 (x)) …))
​
​
​
​
嚙み砕いた説明
Composeは、画像やデータに対して一連の処理をまとめて適用するためのツール。例えば、画像のサイズ変更、クロッ
プ、正規化などを一度に行いたいときに便利。
変換を一つにまとめることで、コードがすっきりし、再利用性が高まる。逐次的に変換を適用するため、処理の流れを簡単
に追うことができる。


# Page. 11

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

実際の応用例
例えば、画像認識のモデルを学習させる際、画像データに様々な前処理を施す必要がある。ここでComposeを使うと、以
下のようにコードを記述することができる。
import torchvision.transforms as transforms
from PIL import Image
# 画像変換のリストを定義
transform = transforms.Compose([
transforms.Resize((256, 256)),
# サイズ変更
transforms.CenterCrop(224),
# 中央をクロップ
transforms.ToTensor(),
# テンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# 正規化
])
# 画像を読み込み
image = Image.open(&#039;path/to/your/image.jpg&#039;)
# 定義した変換を画像に適用
transformed_image = transform(image)
# `transformed_image`は学習モデルに直接入力可能な形式となる
上記のコードでは、画像を読み込んだ後に一連の変換を適用し、学習に適した形式へと変換している。こうすることで、画
像データの前処理が簡潔に記述され、再利用が容易になる。
ToTensor
定義や意味
ToTensor は、PythonのライブラリであるTorchvisionのTransformsモジュールに含まれる機能の一つ
画像データをPIL形式（Python Imaging Library）またはNumpy配列からPyTorchのテンソル形式に変換するためのクラス
画像のピクセル値を[0, 255]の範囲から[0, 1]の範囲に正規化する役割も果たす
嚙み砕いた説明
ToTensor は、画像を数値データに変えるための変換ツール
画像をPyTorchで扱える形にするために、画像をテンソルという形式に変換する
これにより、画像データをニューラルネットワークでそのまま利用可能になる
例えば、画像の赤、緑、青の各ピクセル値が0から255の範囲であるところを、0から1の範囲にスケールダウンする
実際の応用例
ToTensor は、画像データをPyTorchのニューラルネットワークモデルに入力する際に一般的に使用される
データ前処理のステップとして、画像の読み込み後に適用される
例えば、画像分類タスクにおけるデータセットの前処理で使用される


# Page. 12

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

from torchvision import transforms
from PIL import Image
# 画像を読み込む
image = Image.open(&#039;example.jpg&#039;)
# ToTensor変換を適用
transform = transforms.ToTensor()
tensor_image = transform(image)
# tensor_imageはPyTorchのテンソルとして表現される
# ピクセル値は[0,1]の範囲にスケールされている
上記のコードスニペットでは、PIL形式の画像をPyTorchのテンソルに変換している
変換後のテンソルは、モデルに入力するための準備が整っている状態
Normalize
定義や意味
正規化（Normalize）とは、データやベクトルのスケールを調整するプロセスを指す。具体的には、データの範囲を特定の
スケールに収めることを意味する。特に、ベクトルの正規化はその長さを1に調整することを指す。
数学的には、ベクトル v の正規化はそのベクトルをそのノルム（大きさ）で割ることによって行われる。ノルムは一般的
に以下のように定義される：
∥v∥ =
v12 + v22 + ⋯ + vn2
​
​
​ ​
したがって、正規化されたベクトル u は次のように計算される：
u=
v
∥v∥
​
嚙み砕いた説明
正規化は、データを一貫したスケールにすることで、計算を安定させたり比較を容易にするために使用される。例えば、画
像データでは各ピクセル値を0から1の範囲に収めることが一般的。
日常の例として、異なる単位の測定値（例えば、メートルとキログラム）を比較可能にするために、それらを標準化するよ
うな操作と考えることができる。
実際の応用例
画像処理や機械学習において、データを統一的に扱いやすくするために正規化が使用される。特にディープラーニングの分
野では、ネットワークに入力する前に画像データを正規化することが一般的。
torchvision ライブラリでは、画像を正規化するために transforms.Normalize が使用される。この関数は平均と標準偏差
を用いて画像のピクセル値を正規化する。
以下に torchvision を用いた画像の正規化の具体例を示す：


# Page. 13

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

import torch
from torchvision import transforms
# 画像データの正規化のための変換を定義
# 画像チャンネルごとの平均と標準偏差を指定
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# 通常のトランスフォームのパイプラインに正規化を組み込む
transform = transforms.Compose([
transforms.ToTensor(),
# 画像をテンソルに変換
normalize
# 正規化を適用
])
# サンプルのテンソル画像にトランスフォームを適用
sample_tensor = torch.rand((3, 256, 256))
# ダミーの3チャンネル画像
normalized_tensor = transform(sample_tensor)
print(normalized_tensor)
このコードスニペットでは、画像の各チャンネルに対して指定された平均と標準偏差を用いて正規化を行う。これは、学習
済みネットワークが期待する入力の範囲にデータを正規化するために重要。
RandomCrop
定義や意味
RandomCropは画像処理におけるデータ拡張手法の一つで、指定されたサイズのランダムな領域を画像から切り抜く操作を
指す。これにより、データセット内の多様性を増やし、モデルの汎化性能を向上させることが期待される。
変換の数学的表現は次の通り：元の画像をI とし、切り抜く領域のサイズを(h, w)とする。切り抜かれる領域の左上の座標
を(x, y)とすると、x ∼ Uniform(0, H − h), y ∼ Uniform(0, W − w)に従う確率変数である。ここで、H とW は元
の画像の高さと幅。
嚙み砕いた説明
RandomCropは、画像の一部をランダムに選んで切り取ることで、データセットを増やすテクニック。例えば、大きな風景
写真からランダムに小さな部分を切り取ることで、様々なバリエーションのデータを作り出すことができる。これにより、
モデルは異なる位置やスケールでの物体認識ができるようになる。
実際の応用例
RandomCropは特に画像分類タスクや物体検出タスクで使用される。CNNなどの深層学習モデルにおいて、過学習を防
ぎ、データセットに含まれる物体の多様な位置やサイズに対してロバストなモデルを訓練するために利用される。


# Page. 14

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

import torchvision.transforms as transforms
from PIL import Image
# 画像をランダムにクロップするためのトランスフォームを定義
transform = transforms.RandomCrop(size=(128, 128))
# PIL Imageを読み込む
image = Image.open(&#039;example.jpg&#039;)
# トランスフォームを適用してランダムクロップを実行
cropped_image = transform(image)
# 結果を表示または保存する
cropped_image.show()
# または cropped_image.save(&#039;cropped_example.jpg&#039;)
上記のコードスニペットは、PythonのTorchvisionライブラリを用いて、画像をランダムに128x128のサイズにクロップする
方法を示す。 transforms.RandomCrop クラスを用いて、指定したサイズでランダムにクロップを適用し、データセットの多
様性を増す。
RandomHorizontalFlip
定義や意味
RandomHorizontalFlip は、画像データの水平方向の反転をランダムに適用するデータ拡張手法の一つ
主にディープラーニングの画像分類タスクにおいて、モデルの汎化性能を向上させる目的で使用
確率 p に基づいて、入力画像を左右逆に反転する操作
反転するかどうかは確率変数に依存し、確率 p で反転を行う
数式で表すと、入力画像を I としたとき、反転後の画像 I ′ は以下のように表せる：
I′ = {
flip(I) with probability p
I
with probability (1 − p)
​
​
嚙み砕いた説明
RandomHorizontalFlip は写真を左右逆にする操作で、まるで鏡に映したような効果を作る
例えば、人の顔が向かって右を向いている画像があった場合、これを反転させると顔は左を向く
これをランダムに行うことで、モデルが特定の方向にバイアスを持たないようにする
例えば、犬の画像を学習する際に、すべての画像が同じ方向を向いていると、モデルはその方向に対してのみ強い性能を示
す可能性がある
実際の応用例
ディープラーニングにおける画像データの前処理で使用される
特に画像分類や物体検出などのタスクで、データを多様化しモデルの過学習を防ぐために用いる
PyTorchの torchvision.transforms モジュールで簡単に利用可能


# Page. 15

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

import torchvision.transforms as transforms
# 確率0.5で水平方向に画像を反転する
transform = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
# 他の変換処理をここに追加
])
# 使用例：Datasetに適用
from torchvision.datasets import CIFAR10
from torchvision.transforms import ToTensor
# CIFAR-10データセットをインポートし、前処理を適用
dataset = CIFAR10(root=&#039;data&#039;, train=True, download=True, transform=transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
ToTensor()
]))
# データローダーでバッチを作成
from torch.utils.data import DataLoader
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
# データローダーから画像を取得し、反転効果を確認
import matplotlib.pyplot as plt
import numpy as np
data_iter = iter(dataloader)
images, labels = data_iter.next()
# 最初の画像をプロット
plt.imshow(np.transpose(images[0].numpy(), (1, 2, 0)))
plt.show()
このコードスニペットは、 CIFAR-10 データセットに対して RandomHorizontalFlip を適用する例
確率0.5で各画像が左右逆に反転され、異なる方向の画像をモデルに提供することができる
これにより、モデルが特定の方向に対してのみ学習することを防ぎ、よりロバストな性能を獲得する
ResNet
定義や意味
ResNet（Residual Network）は、ディープニューラルネットワークの一種で、層が非常に深いネットワークにおける学習
の難しさを克服するために開発されたアーキテクチャ
ResNetは「スキップ接続（skip connections）」または「ショートカット接続（shortcut connections）」を導入し、層間の
情報の流れを改善する
基本的なアイデアは、各層が直接学習するのではなく、前の層との差分（残差）を学習すること
数式で表現すると、ある層の出力 H(x) が F (x) + x の形で表される。ここで F (x) は学習する残差であり、x は入力
H(x) = F (x) + x
嚙み砕いた説明
ResNetは、通常のニューラルネットワークに比べて非常に多くの層を持つことが可能なネットワーク


# Page. 16

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

例えば、層が100枚以上の画像分類タスクでも、ResNetは有効に機能する
通常の深いニューラルネットワークでは、情報が層を通過するたびに弱まる（消失勾配問題）が、ResNetではスキップ接
続により直接的な情報伝達が行われるため、この問題を軽減する
スキップ接続は、情報が入力から出力まで直接伝わるようにすることで、ネットワークの学習を容易にする
実際の応用例
ResNetは画像分類、物体検出など、コンピュータビジョンの多くの分野で活用されている
特にImageNetのような大規模データセットの分類タスクで優れた性能を示す
PyTorchのtorchvisionライブラリには、ResNetの事前学習済みモデルが用意されており、簡単に利用可能
以下は、PyTorchでResNetを利用する際のコード例
import torch
import torchvision.models as models
# ResNet-18を事前学習済みの重みで読み込む
resnet18 = models.resnet18(pretrained=True)
# モデルの概要を表示
print(resnet18)
# 入力データのテンソルを作成（例として3チャンネルの224x224画像）
input_tensor = torch.randn((1, 3, 224, 224))
# モデルを推論モードに設定
resnet18.eval()
# 推論を実行
output = resnet18(input_tensor)
# 出力のサイズを確認（通常1000クラスの分類）
print(output.size())
# torch.Size([1, 1000])
上記のコードでは、torchvisionのResNet-18モデルを使用して、入力画像のクラスを予測
pretrained=True を指定することで、ImageNetで事前に学習された重みを利用可能
推論モードで入力データをモデルに通すことで、出力が得られる
VGG
定義や意味
VGGは、2014年に発表された深層畳み込みニューラルネットワーク（CNN）の一種で、特に画像認識において高い性能を
発揮するモデルの一つとして知られる
VGGネットワークは、非常に深い層を持ち、特に3x3の小さいフィルタを重ねることにより、深いネットワーク構造を実現
する
VGG16やVGG19などが代表的なモデルであり、これらの数値はネットワークの層の数を示す
入力画像に対する出力特徴マップを生成するプロセスは、以下のように一般化できる
f (x) = Wn (Wn−1 (...W2 (W1 (x))...))
​
ここで、Wi は各層の重みを表し、xは入力画像を表す
​
​
​
​


# Page. 17

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

嚙み砕いた説明
VGGは、画像を理解するために多くの層を持つ神経ネットワークで、これにより画像の詳細や特徴を捉える
小さなフィルタをたくさん使って、画像の細かい部分を少しずつ見ることができる
VGGはとても深く、同じ種類のフィルタを何度も重ねることで、画像のより高いレベルの特徴を捉えることができる
実際の応用例
VGGは画像分類、物体検出、セグメンテーションなど、コンピュータビジョンの多くのタスクで使用される
特に、事前学習済みのVGGモデルは、転移学習において非常に有用であり、他のデータセットに対して再利用されること
が多い
以下は、PyTorchおよびTorchvisionライブラリを用いて、事前学習済みのVGG16モデルをロードし、画像の分類を行う例
import torch
import torchvision.models as models
from torchvision import transforms
from PIL import Image
# 事前学習済みのVGG16モデルをロード
vgg16 = models.vgg16(pretrained=True)
# モデルを評価モードに
vgg16.eval()
# 入力画像の前処理
preprocess = transforms.Compose([
transforms.Resize(256),
# 画像のリサイズ
transforms.CenterCrop(224),
transforms.ToTensor(),
# 画像の中央部分を切り取り
# テンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# 正規化
])
# 画像の読み込みと前処理
img = Image.open(&quot;path/to/your/image.jpg&quot;)
img_tensor = preprocess(img)
img_tensor = img_tensor.unsqueeze(0)
# バッチサイズの次元を追加
# モデルに画像を入力して推論
with torch.no_grad():
output = vgg16(img_tensor)
# 出力の最大値を持つインデックスを取得し、クラスラベルを特定
_, predicted = torch.max(output, 1)
print(&quot;Predicted class:&quot;, predicted.item())
このスニペットでは、PyTorchのTorchvisionを使用してVGG16モデルを簡単に利用し、画像の分類を行う例を示している
モデルは事前学習済みであるため、すぐに利用可能な状態になっている
AlexNet
定義や意味
AlexNetは、2012年にAlex Krizhevskyらによって提案された深層畳み込みニューラルネットワーク(CNN)で、画像認識タス
クにおける大規模データセットでの性能向上を目的としている


# Page. 18

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

主に5つの畳み込み層と3つの全結合層、ReLU活性化関数、ドロップアウト、そしてローカル応答正規化(LRN)を用いてい
る
出力層は1000クラスの分類を行うためのSoftmax関数を使用
このネットワークはImageNet Large Scale Visual Recognition Challenge (ILSVRC) 2012において優勝し、深層学習の重要
性を広く認知させた
嚙み砕いた説明
AlexNetは画像を入力として受け取り、その画像が何であるかを分類するためのモデル
畳み込み層で画像の特徴を抽出し、全結合層で最終的なクラスの予測を行う
ReLUを用いることで非線形性を導入し、ドロップアウトを用いて過学習を防ぐ
ネットワークの各層は次の層への入力として出力を渡すことで、データが次第に高次の特徴に変換される
実際の応用例
AlexNetは画像分類や物体認識、さらには画像生成のタスクで利用される
PyTorchのtorchvisionライブラリでは、AlexNetの事前訓練されたモデルが利用可能であり、転移学習などに用いられる
import torch
import torchvision.models as models
from torchvision import transforms
from PIL import Image
# AlexNetの事前訓練されたモデルをロード
model = models.alexnet(pretrained=True)
model.eval()
# 画像の前処理
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# 画像の読み込みと変換
img = Image.open(&quot;path_to_image.jpg&quot;)
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0)
# 推論
with torch.no_grad():
output = model(batch_t)
# 出力のクラスを取得
_, predicted = torch.max(output, 1)
print(predicted.item())
# クラスのインデックスを出力
このコードは、画像をAlexNetに入力し、その画像が何を表しているかを予測する
models.alexnet(pretrained=True) で事前訓練されたAlexNetを使用し、 preprocess で画像をネットワークに入力可能な形式
に変換
最後に、 torch.max を用いて予測されたクラスのインデックスを取得し表示


# Page. 19

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

MobileNet
定義や意味
MobileNetは、モバイルや組み込みデバイスなどのリソース制約のある環境での使用を目的として設計された軽量な畳み込
みニューラルネットワーク（CNN）である
MobileNetは、畳み込み操作を効率化するために「深さ方向畳み込み（Depthwise Convolution）」と「ポイント畳み込み
（Pointwise Convolution）」を組み合わせた「深さ方向可分畳み込み（Depthwise Separable Convolution）」を使用する
深さ方向可分畳み込みにより、従来の畳み込みに比べて計算量とパラメータ数が大幅に削減される
MobileNetの計算量は主に次の式で表される：
CostDepthwise = Dk ⋅ Dk ⋅ Cin ⋅ H ⋅ W
​
​
​
​
CostPointwise = Cin ⋅ Cout ⋅ H ⋅ W
​
​
​
ここで、Dk はカーネルサイズ、Cin は入力チャネル数、Cout は出力チャネル数、H と W は特徴マップの高さと幅であ
る
​
​
​
嚙み砕いた説明
MobileNetは、スマホやタブレットなどの限られた計算能力と電力消費のデバイスで動作するように設計された軽量なニュ
ーラルネットワーク
通常の畳み込み層は、各フィルターがすべての入力チャネルを同時に見るが、MobileNetの深さ方向畳み込みでは、各フィ
ルターが1つのチャネルだけを見て計算するため、計算がシンプルで速くなる
その後、ポイント畳み込みで結果を統合することで、モデル全体の効率性を向上させる
実際の応用例
MobileNetは、物体認識、顔検出、ジェスチャー認識などのリアルタイムアプリケーションでよく使用される
PyTorchのTorchvisionライブラリを使用してMobileNetを簡単に利用することが可能
import torch
from torchvision import models
# MobileNetV2のロード
mobilenet_v2 = models.mobilenet_v2(pretrained=True)
# モデルの概要を表示
print(mobilenet_v2)
# モデルを使った推論の例
# ダミー入力データを作成（バッチサイズ1、チャネル3、サイズ224x224）
input_data = torch.randn(1, 3, 224, 224)
# 推論を実行
output = mobilenet_v2(input_data)
# 出力のサイズを表示
print(output.size())
上記のコードでは、Torchvisionの models モジュールから mobilenet_v2 をロードし、事前学習済みの重みを使用してモデル
をセットアップ


# Page. 20

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

モデルにダミーの入力データを与えて推論を実行し、出力のサイズを確認することで、モデルが期待通りに動作することを
確認可能
Inception
定義や意味
Inceptionとは、ニューラルネットワークの一種であり、特に畳み込みニューラルネットワーク（CNN）のアーキテクチャ
の一つを指す。Googleの研究者によって提案されたInceptionアーキテクチャは、2014年に発表された「Going Deeper with
Convolutions」という論文で紹介された。Inceptionの主な特長は、異なるサイズの畳み込みフィルタを同時に使い、さまざ
まなスケールで特徴を抽出することである。
Inceptionモジュールでは、1 × 1, 3 × 3, 5 × 5の畳み込み層と、プーリング層を並行して適用し、それらの出力を結合す
る。この多様なフィルタサイズにより、局所的な特徴と広域的な特徴を同時に捉えることが可能となる。
次の数式でInceptionモジュールの出力を表現できる：
Output = Concat(Conv1×1 (x), Conv3×3 (x), Conv5×5 (x), Pooling(x))
​
​
​
ここで、Concatは各畳み込みとプーリングの出力を連結する操作を示す。
嚙み砕いた説明
Inceptionモジュールは、異なるサイズの「フィルタ」を使って画像の特徴を調べることを目的としている。これは、画像
の中にある小さな特徴（例えば、エッジや角）と大きな特徴（例えば、物体全体）を同時に認識するのに役立つ。
異なるサイズのフィルタを使うことで、ネットワークはより多様な視点から入力データを解析し、より精緻な情報を得るこ
とができる。
例えるなら、Inceptionは一つの画像を詳細に観察するために、虫眼鏡、顕微鏡、望遠鏡を同時に使うようなもの。
実際の応用例
Inceptionは、画像認識やオブジェクト検出の分野で広く応用されている。
特に、Googleの画像認識システムなど多くの実世界のアプリケーションで使用され、ImageNetのようなコンペティション
で優れた性能を示している。
PyTorchのtorchvisionライブラリを使って、Inceptionアーキテクチャを簡単に実装できる。
以下に、torchvisionを用いたInceptionモデルの使用例を示す：
import torch
import torchvision.models as models
# InceptionV3モデルを読み込む
model = models.inception_v3(pretrained=True)
# モデルを評価モードに設定
model.eval()
# ダミー入力データ（3チャンネルの224x224画像）を作成
dummy_input = torch.randn(1, 3, 299, 299)
# モデルの出力を取得
output = model(dummy_input)
# 出力を確認
print(output)


# Page. 21

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

このコードスニペットは、torchvisionからInceptionV3モデルをロードし、ランダムな入力データを与えて出力を得る例で
ある。
pretrained=True を指定することで、ImageNetデータセットで事前学習された重みを使用可能。
DataLoader
定義や意味
DataLoaderは、データセットを効率的に読み込むためのパイプラインを提供するPyTorchのモジュールである。データセッ
トのバッチ処理、シャッフル、並列処理をサポートし、モデルのトレーニングにおけるデータ供給を最適化する役割を担
う。
DataLoaderは、 torch.utils.data.DataLoader クラスとして定義され、主に以下のパラメータを持つ:
dataset : データを供給するデータセットオブジェクト
batch_size : 一度にロードするサンプルの数
shuffle : データをシャッフルするかどうか
num_workers : データの読み込みに用いるスレッド数
嚙み砕いた説明
DataLoaderは、大量のデータを効率的にモデルに供給するためのツールである。データを小さな塊（バッチ）に分けて、
それを順次モデルに渡すことで、メモリの使用量を抑えながら高速なトレーニングを可能にする。
例えば、データセットが10,000個の画像で構成されているとき、DataLoaderを使用すると、100個ずつの画像をバッチとし
てモデルに渡すことができる。これにより、メモリの負担を軽減しつつ、GPUの並列処理能力を活用できる。
実際の応用例
DataLoaderは、画像認識モデルのトレーニングプロセスにおいて、データ供給の効率化のために広く用いられる。特に、
大規模なデータセットを扱う際にその効果が顕著である。
以下に、Torchvisionを用いたDataLoaderの使用例を示す。
import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# データ変換の定義
transform = transforms.Compose([
transforms.ToTensor(),
# 画像をテンソルに変換
transforms.Normalize((0.5,), (0.5,))
# 正規化
])
# データセットのダウンロードと読み込み
train_dataset = datasets.MNIST(root=&#039;./data&#039;, train=True, download=True, transform=transform)
# DataLoaderの設定
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True, num_workers=2)
# DataLoaderを使ったデータの反復処理
for images, labels in train_loader:
# imagesとlabelsでバッチ処理を実行
pass
# モデルのトレーニング処理を記述
上記のコードでは、MNISTデータセットを用いてDataLoaderを設定し、バッチサイズ64でシャッフルしながらデータを供
給している。これにより、モデルトレーニングの効率が向上する。


# Page. 22

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

make_grid
定義や意味
make_grid は、PyTorchにおける画像データの視覚化を支援するための関数で、複数の画像を1枚のグリッド画像として配置
する機能を提供する
主に画像データセットのサンプルを確認する際に使用され、 torchvision ライブラリの utils モジュールに含まれている
関数としての基本的な定義は以下のようになる
make_grid(tensor, nrow = 8, padding = 2, normalize = F alse, range = N one, scale_each = F alse, pad_value = 0)
ここで、 tensor は画像のバッチ、 nrow は1行あたりに配置する画像の数、 padding は画像間のスペース、 normalize は画
像の正規化、 range は正規化の範囲、 scale_each は各画像を独立して正規化するかの指定、 pad_value はパディングスペ
ースの値を決定する
嚙み砕いた説明
make_grid は、複数の画像を一つの大きな画像として配置するための関数
例えば、10個の画像を2行5列に並べることで、1枚の大きな画像として表示できる
画像データセットを可視化する際に、どのような画像データが含まれているかを一目で確認するのに便利
実際の応用例
画像分類モデルのトレーニング時に、データセットのサンプルを確認するために使用される
以下のコードスニペットは、 torchvision のデータセットを使って画像をロードし、 make_grid を用いて画像をグリッド形
式で表示する例
import torch
import torchvision
import torchvision.transforms as transforms
from torchvision.utils import make_grid
import matplotlib.pyplot as plt
# データセットの変換を定義
transform = transforms.Compose([
transforms.ToTensor(),
])
# CIFAR10データセットをダウンロード
trainset = torchvision.datasets.CIFAR10(root=&#039;./data&#039;, train=True,
download=True, transform=transform)
# データローダーを作成
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
# データローダーからサンプルを取得
dataiter = iter(trainloader)
images, labels = dataiter.next()
# 画像をグリッド形式で表示
grid = make_grid(images)
plt.imshow(grid.permute(1, 2, 0))
plt.show()
# 画像の次元を調整して表示


# Page. 23

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

この例では、CIFAR-10データセットから4つの画像を取得し、 make_grid を用いてグリッド形式に変換して表示
plt.imshow を用いてグリッド画像を表示し、データセットのサンプルを視覚的に確認可能にする
save_image
定義や意味
save_image は、PyTorchの画像処理に関連するライブラリであるTorchvisionが提供する関数の一つ
主にテンソル形式の画像データをファイルに保存するために使用される
画像の保存形式は一般的にPNGやJPEGなどの標準的な画像フォーマットを指定できる
画像の保存時に正規化やクリッピングを行うことが可能で、画像のピクセル値を[0, 1]の範囲に収めることができる
嚙み砕いた説明
save_image 関数は、PyTorchで扱うテンソルデータ（画像データ）を、コンピュータ上のファイルとして保存するための便
利な関数
例えば、トレーニング中に生成した画像や変換した画像をディスクに保存して、後で確認や分析に使うことができる
保存する際に、画像のピクセル値を調整したり、特定のファイル形式で保存することができる
実際の応用例
機械学習モデルのトレーニング中に生成された画像の中間結果を保存し、モデルの動作を視覚的に確認するために使用され
る
データオーグメンテーションの結果をファイルに保存し、後で確認するために用いる
以下は save_image 関数を使った簡単なコードスニペットの例：
import torch
from torchvision.utils import save_image
# ランダムなテンソルを生成（3チャンネルの画像、サイズは64x64）
image_tensor = torch.randn(3, 64, 64)
# 画像を保存（current_directory/output.png）
save_image(image_tensor, &#039;output.png&#039;)
# オプションで正規化を行う
# ピクセル値を[0, 1]の範囲にクリップして保存
save_image(image_tensor, &#039;output_normalized.png&#039;, normalize=True)
このスニペットでは、ランダムに生成されたテンソルを画像ファイルとして保存している。 normalize=True を指定することで、画
像のピクセル値を0から1の範囲にクリップし、保存することができる。
Preprocessing
定義や意味
Preprocessing（前処理）とは、データを機械学習モデルに入力する前に行う一連の変換や操作のことを指す。これによ
り、データの品質を向上させ、学習アルゴリズムの性能を最大限に引き出すことができる。前処理には、データの正規化、
標準化、拡張、クリーニングなどが含まれる。特に画像処理においては、リサイズ、クロップ、回転、正規化など様々な操
作が行われる。


# Page. 24

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

数式による具体例として、画像の正規化を考える。画像データを0から1の範囲にスケーリングする場合、各ピクセル値xを
その最大値255で割ることで以下のように表現できる：
xnormalized =
​
x
255
​
嚙み砕いた説明
Preprocessingは、データを「整える」作業のこと。たとえば、画像データをそのままではなく、サイズを統一したり、明
るさやコントラストを調整したりすることで、機械学習モデルがデータをより効果的に学習できるようにする。これは、料
理をする前に材料を切ったり計量したりするのに似ている。データを「調理」する準備を整えるためのステップである。
具体例として、画像の前処理では、画像のサイズを統一するためにリサイズを行ったり、学習の安定性を高めるためにピク
セル値を0から1の範囲に正規化したりする。
実際の応用例
Preprocessingは、画像分類や物体検出などのタスクで広く応用されている。特に、PyTorchのTorchvisionライブラリで
は、画像データに対する様々な前処理を簡単に行うことができる。
具体例として、Torchvisionを用いた画像の前処理コードスニペットを示す。
import torchvision.transforms as transforms
from PIL import Image
# 前処理の定義
preprocess = transforms.Compose([
transforms.Resize(256),
# 画像を256x256にリサイズ
transforms.CenterCrop(224),
# 中央を224x224でクロップ
transforms.ToTensor(),
# テンソルに変換
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # 正規化
])
# 画像の読み込み
img = Image.open(&quot;path/to/image.jpg&quot;)
# 画像に前処理を適用
img_tensor = preprocess(img)
# img_tensorは前処理された画像データ
このコードでは、画像を256x256にリサイズし、中央を224x224でクロップし、テンソル形式に変換した後、一般的な平均
と標準偏差で正規化を行っている。これらの処理により、画像データがニューラルネットワークモデルに適した形式に変換
される。
Augmentation
定義や意味
Augmentation（オーグメンテーション）とは、データ拡張のことであり、主に機械学習やディープラーニングにおいて、
データセットを人工的に増加させる手法を指す。データ量を増やすことで、モデルの過学習（overfitting）を防ぎ、一般化
性能を向上させることが目的。
具体的には、画像データに対して、回転、平行移動、反転、色調変更、ノイズ付加などの変換を適用する。これにより、元
のデータセットを拡張し、多様なデータに対してモデルを学習させることができる。
数式で表すと、画像データ x に対して、変換関数 f を適用し、新たなデータ x′ を生成する。すなわち、x′ = f (x) とな
る。


# Page. 25

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

嚙み砕いた説明
Augmentationとは、データを増やすために画像をいじくる方法のこと。例えば、ある猫の写真を右に回転させたり、上下
逆にしたり、明るさを変えたりして、たくさんのバリエーションを作る。このようにすることで、機械学習モデルが「この
猫だけ覚える」のではなく、「いろんな猫の写真に対応できるように」訓練する。
たとえば、あなたがジグソーパズルを作るときに、同じピースを違う向きに回したり、色を変えたりすることでより多くの
異なるパターンを作ることと似ている。
実際の応用例
Augmentationは、特に画像認識タスクにおいて、データ量が少ない場合に非常に有効である。例えば、猫と犬を分類する
モデルを訓練する際に、各クラスの画像が少ないときに使われる。
PyTorchのライブラリであるTorchvisionでは、簡単に画像データのAugmentationを行うことができる。以下にPythonコード
スニペットを示す。
import torchvision.transforms as transforms
from PIL import Image
# 画像データのオーグメンテーションの設定
transform = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
# 50%の確率で画像を水平反転
transforms.RandomRotation(degrees=45),
# -45度から45度の範囲でランダムに回転
transforms.ColorJitter(brightness=0.5),
# 明るさをランダムに調整
transforms.RandomResizedCrop(224),
# 画像を224x224にランダムにクロップ
])
# 画像を読み込む
image = Image.open(&#039;cat.jpg&#039;)
# 上記のオーグメンテーションを適用
augmented_image = transform(image)
# 変換後の画像を表示
augmented_image.show()
このコードでは、猫の画像を水平反転、ランダム回転、明るさ調整、ランダムクロップといった変換を施している。これに
より、元の画像から多様なバリエーションが得られ、モデルの訓練に役立つ。
Annotation
定義や意味
Annotation（アノテーション）は、データに対して何らかのラベルやメタデータを付与する行為を指す。特に、機械学習や
ディープラーニングの分野では、画像やテキストデータに対してラベルを付与することによって、モデルがデータを学習し
やすくするために使用される。
画像データにおけるアノテーションは、物体検出、画像分類、セグメンテーションなどのタスクにおいて重要な役割を果た
す。たとえば、画像データに対して各物体の位置やカテゴリを示すバウンディングボックスを付与することが一般的。
嚙み砕いた説明
アノテーションとは、データに対して「これは何か」を教えるための情報を付け加えることである。たとえば、猫の画像に
「猫」というラベルを付けたり、画像の中で猫がどこにいるのかを示すために四角形で囲んだりすることが該当する。
これによりコンピュータやモデルがデータを理解しやすくなり、何をどう学習すべきかを明示的に示すことができる。


# Page. 26

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

実際の応用例
ディープラーニングにおいて、アノテーションは訓練データセットのラベル付けに用いられる。これにより、モデルは入力
データとラベルを用いて学習を行い、新しいデータに対して推論を行うことが可能になる。
TorchvisionはPyTorchの一部であり、画像データの変換やデータセットの利用を簡単にするためのツールを提供する。アノ
テーションはTorchvisionのデータセットの一部として扱われることが多い。
以下に、Torchvisionを用いた簡単なアノテーションの例を示す。
import torchvision.transforms as transforms
from torchvision.datasets import VOCDetection
# Pascal VOCデータセットをロードし、画像とアノテーションを取得
dataset = VOCDetection(root=&#039;path/to/VOCdevkit/&#039;, year=&#039;2012&#039;, image_set=&#039;train&#039;, download=True)
# データセットのサンプルを取得
image, target = dataset[0]
# 画像の表示
image.show()
# アノテーションの表示
print(target)
# アノテーションの内容は辞書形式で、物体のラベルや位置情報を含む
# 例: {&#039;annotation&#039;: {&#039;object&#039;: [{&#039;name&#039;: &#039;cat&#039;, &#039;bndbox&#039;: {&#039;xmin&#039;: 50, &#039;ymin&#039;: 50, &#039;xmax&#039;: 200, &#039;ymax&#039;: 200}}]}}
上記のコードでは、Torchvisionの VOCDetection クラスを使用して、Pascal VOCデータセットをロードし、画像とそのアノ
テーションを取得している。アノテーションは辞書形式で、画像中の物体のラベル（例：&#039;cat&#039;）やバウンディングボックス
の位置情報が含まれている。
このようなアノテーションを利用することで、物体検出モデルを学習させることができる。
Digit Recognition
定義や意味
Digit Recognitionは、手書きや印刷された数字を画像データから認識するタスクのこと
主に機械学習やディープラーニングを用いて実現される
画像を入力として受け取り、対応する数字（0から9のいずれか）を出力する
具体的には、入力画像のピクセル値が特徴量として扱われ、ニューラルネットワークがそれを学習し、正しい数字を予測す
る
多クラス分類問題の一つとしても扱われる
数式で表すと、入力画像 X ∈ Rm×n に対して、モデル f が予測する出力 y = f (X) は y ∈ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
である
嚙み砕いた説明
Digit Recognitionは、コンピュータが手書きの数字を理解する技術
例えば、銀行の小切手や郵便物の番号を読み取るときに使われる
画像を見て、コンピュータがそれがどの数字かを判断すること
ディープラーニングでは、コンピュータにたくさんの手書き数字の画像を見せて、正しい答えを学習させる


# Page. 27

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

一度学習が終わると、新しい手書き数字を見たときに、それが何かを予測できる
実際の応用例
手書き数字認識は、郵便番号の読み取りや、スマートフォンの手書き入力変換アプリに利用されている
また、銀行や金融機関で小切手の処理にも用いられている
以下に、PyTorchとTorchvisionを用いた基本的なDigit Recognitionの例を示す
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# データセットの準備
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST(root=&#039;./data&#039;, train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
# モデルの定義
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = x.view(-1, 28 * 28)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
model = SimpleNet()
# 損失関数と最適化手法の設定
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# 学習ループ
for epoch in range(5):
for data, target in train_loader:
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
print(f&#039;Epoch {epoch + 1}, Loss: {loss.item()}&#039;)
# このコードはMNISTデータセットを使って手書き数字の認識を行う
# 単純なニューラルネットワークを用いて学習し、交差エントロピー損失を最小化する
上記のコードは、PyTorchを使用してMNISTデータセットで手書き数字を認識する基本的な例


# Page. 28

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

SimpleNet は単純な2層のニューラルネットワークで、28x28の画像を入力として10クラス（数字0〜9）に分類する
学習ループでは、損失を計算し、誤差逆伝播法を用いてモデルを更新する


