Pythonで始めるディープラーニング(深層学習) TensorFlow/PyTorch入門

# 1) プロジェクト用ディレクトリを作成
mkdir dl-intro && cd dl-intro

# 2) 仮想環境を作成と有効化 (Windows)
python -m venv .venv
.venv\Scripts\activate

#    macOS/Linux
# python3 -m venv .venv
# source .venv/bin/activate

# 3) パッケージ管理ツールを最新化
python -m pip install --upgrade pip setuptools wheel

pip install --upgrade tensorflow

# 例: 近年のTensorFlowでCUDA/CuDNNを同時に入れる
pip install "tensorflow[and-cuda]"

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# CUDA 12.6 向けの例
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

# gpu_check.py
# TensorFlow と PyTorch の GPU 検出を一括で確認します
import sys

print("Python:", sys.version)

try:
    import tensorflow as tf
    gpus_tf = tf.config.list_physical_devices("GPU")
    print("[TensorFlow] GPUs:", gpus_tf)
except Exception as e:
    print("[TensorFlow] Import/Check error:", e)

try:
    import torch
    print("[PyTorch] cuda.is_available:", torch.cuda.is_available())
    if torch.cuda.is_available():
        print("[PyTorch] device name:", torch.cuda.get_device_name(0))
        print("[PyTorch] cuda version:", torch.version.cuda)
except Exception as e:
    print("[PyTorch] Import/Check error:", e)

# tf_tensor_basics.py
import tensorflow as tf

# 定数テンソル
a = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
b = tf.ones((2, 2))

# 基本演算
c = a + b
d = tf.matmul(a, b)

print("a:", a.numpy())
print("b:", b.numpy())
print("c = a + b:", c.numpy())
print("d = a @ b:", d.numpy())

# tf_layers_basic.py
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# シンプルな全結合ネットワーク
model = keras.Sequential([
    layers.Input(shape=(4,)),           # 入力は4次元ベクトル
    layers.Dense(8, activation="relu"), # 隠れ層
    layers.Dense(3, activation="softmax") # 出力は3クラス
])

model.summary()

# tf_data_mnist.py
import tensorflow as tf
from tensorflow.keras import datasets

# データのロード
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()

# スケーリングとチャンネル次元の追加(28x28 -> 28x28x1)
x_train = (x_train / 255.0).astype("float32")[..., None]
x_test  = (x_test  / 255.0).astype("float32")[..., None]

print("x_train:", x_train.shape, x_train.dtype)
print("y_train:", y_train.shape, y_train.dtype)
print("x_test:", x_test.shape)

# tf_mnist_minimal_cnn.py
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, datasets

# 1) データ
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_train = (x_train / 255.0).astype("float32")[..., None]
x_test  = (x_test  / 255.0).astype("float32")[..., None]

# 2) モデル定義
model = keras.Sequential([
    layers.Input(shape=(28, 28, 1)),
    layers.Conv2D(16, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax"),
])

# 3) コンパイル(損失と最適化の設定)
model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

# 4) 学習
history = model.fit(
    x_train, y_train,
    validation_split=0.1, # 10%を検証に使う
    epochs=3,
    batch_size=128,
    verbose=2
)

# tf_evaluate.py
import tensorflow as tf
from tensorflow.keras import datasets, layers, models

# ここでは学習済み model を簡潔に再作成して評価のみ例示
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_test  = (x_test / 255.0).astype("float32")[..., None]

# モデルは学習済みのものを想定(上のスクリプトで作った model を再利用する想定)
# ここでは簡易に同じ構造を定義し直してロードの章で重みを復元します。
print("テストデータで評価を実施します。")

# tf_save_infer.py
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, datasets

# 学習(最短で1エポックだけ回して保存例を示す)
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_train = (x_train / 255.0).astype("float32")[..., None]
x_test  = (x_test  / 255.0).astype("float32")[..., None]

model = keras.Sequential([
    layers.Input(shape=(28, 28, 1)),
    layers.Conv2D(16, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.fit(x_train, y_train, epochs=1, batch_size=256, verbose=0)

# 1) 保存
model.save("mnist_cnn.keras")

# 2) ロード
loaded = keras.models.load_model("mnist_cnn.keras")

# 3) 推論(最初のテスト画像で予測)
logits = loaded.predict(x_test[:1], verbose=0)  # 1枚だけ
pred = np.argmax(logits, axis=1)[0]
print("Predicted:", pred, " / True:", int(y_test[0]))

# torch_autograd_basics.py
import torch

# requires_grad=True にすると勾配が追跡される
x = torch.tensor([2.0, 3.0], requires_grad=True)
W = torch.tensor([[1.0, -1.0]], requires_grad=True)  # 1x2 の行列
y = W @ x  # 行列ベクトル積 -> 形状(1,)
loss = (y - 1.0).pow(2).mean()  # シンプルな二乗誤差

loss.backward()  # 勾配計算

print("y:", y.item())
print("d(loss)/dW:", W.grad)
print("d(loss)/dx:", x.grad)

# torch_data_mnist.py
import torch
from torchvision import datasets, transforms

# テンソル化 + 0.1307, 0.3081 はMNISTの平均と標準偏差
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_ds = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
test_ds  = datasets.MNIST(root="./data", train=False, download=True, transform=transform)

train_loader = torch.utils.data.DataLoader(train_ds, batch_size=128, shuffle=True)
test_loader  = torch.utils.data.DataLoader(test_ds,  batch_size=256)

print("train size:", len(train_ds), "/ test size:", len(test_ds))

# torch_mnist_minimal_cnn.py
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 1) データ
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
train_ds = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
test_ds  = datasets.MNIST(root="./data", train=False, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_ds, batch_size=128, shuffle=True)
test_loader  = torch.utils.data.DataLoader(test_ds,  batch_size=256)

# 2) モデル定義
class SmallCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, 3)  # 1x28x28 -> 16x26x26
        self.pool  = nn.MaxPool2d(2)      # 16x26x26 -> 16x13x13
        self.conv2 = nn.Conv2d(16, 32, 3) # 32x11x11
        self.fc1   = nn.Linear(32*5*5, 64)
        self.fc2   = nn.Linear(64, 10)
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))  # -> (32, 5, 5)
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SmallCNN().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

# 3) 学習ループ
def train_epoch(model, loader, optimizer, criterion):
    model.train()
    running_loss, correct, total = 0.0, 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        optimizer.zero_grad()
        logits = model(x)
        loss = criterion(logits, y)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * x.size(0)
        pred = logits.argmax(dim=1)
        correct += (pred == y).sum().item()
        total += y.size(0)
    return running_loss/total, correct/total

def evaluate(model, loader, criterion):
    model.eval()
    loss_sum, correct, total = 0.0, 0, 0
    with torch.no_grad():
        for x, y in loader:
            x, y = x.to(device), y.to(device)
            logits = model(x)
            loss = criterion(logits, y)
            loss_sum += loss.item() * x.size(0)
            pred = logits.argmax(dim=1)
            correct += (pred == y).sum().item()
            total += y.size(0)
    return loss_sum/total, correct/total

for epoch in range(1, 4):
    tr_loss, tr_acc = train_epoch(model, train_loader, optimizer, criterion)
    te_loss, te_acc = evaluate(model, test_loader, criterion)
    print(f"Epoch {epoch}/3 - train loss:{tr_loss:.4f} acc:{tr_acc:.4f} - test loss:{te_loss:.4f} acc:{te_acc:.4f}")

# torch_save_infer.py
import torch
import torch.nn as nn
from torchvision import datasets, transforms

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# モデル定義(学習時と同じ構造)
class SmallCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, 3)
        self.pool  = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(16, 32, 3)
        self.fc1   = nn.Linear(32*5*5, 64)
        self.fc2   = nn.Linear(64, 10)
    def forward(self, x):
        import torch.nn.functional as F
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 1) モデルの初期化と重みロード
model = SmallCNN().to(device)
# ここでは事前に torch.save(model.state_dict(), "mnist_cnn.pt") してある想定
# 学習済みの重みがない場合、この行はエラーになる点に注意してください
try:
    model.load_state_dict(torch.load("mnist_cnn.pt", map_location=device))
    model.eval()
except FileNotFoundError:
    print("mnist_cnn.pt が見つかりません。学習後に保存してから再実行してください。")

# 2) データの用意と単発推論
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
test_ds = datasets.MNIST(root="./data", train=False, download=True, transform=transform)

x, y_true = test_ds[0]  # 先頭の1枚
x = x.unsqueeze(0).to(device)  # (1, 1, 28, 28)
with torch.no_grad():
    logits = model(x)
    pred = logits.argmax(dim=1).item()

print("Predicted:", pred, "/ True:", y_true)