PyTorch入門

import numpy as np
import torch
from torch import nn

print(f"PyTorch: {torch.__version__}")
print(f"NumPy  : {np.__version__}")
print(f"CUDA利用可能: {torch.cuda.is_available()}")

import torch
print(f"PyTorchのバージョン: {torch.__version__}")
print(f"CUDAの利用可能性: {torch.cuda.is_available()}")
print(f"CUDAのバージョン: {torch.version.cuda}")
print(f"CUDNNが有効: {torch.backends.cudnn.enabled}")
print(f"CUDNNのバージョン: {torch.backends.cudnn.version()}")

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.ones((2, 2))

print("x =\n", x)
print("y =\n", y)
print("shape:", x.shape)
print("dtype:", x.dtype)
print("x + y =\n", x + y)
print("x @ y =\n", x @ y)

device = "cuda" if torch.cuda.is_available() else "cpu"
x_on_device = x.to(device)
print("device:", x_on_device.device)

a_np = np.array([1.0, 2.0, 3.0])
b_np = np.array([4.0, 5.0, 6.0])

print("NumPy dot:", a_np @ b_np)

a_t = torch.tensor([1.0, 2.0, 3.0])
b_t = torch.tensor([4.0, 5.0, 6.0])

print("PyTorch dot:", torch.dot(a_t, b_t).item())

# 自動微分の例（requires_grad=True のTensorは勾配追跡される）
w = torch.tensor(2.0, requires_grad=True)
z = w ** 2 + 3 * w
z.backward()
print("dz/dw:", w.grad.item())

# 自動微分をoffにする例1: no_gradコンテキストを使う
with torch.no_grad():
    z_no_grad = w ** 2 + 3 * w
print("no_gradで計算したTensorのrequires_grad:", z_no_grad.requires_grad)

# 自動微分をoffにする例2: detachで計算グラフから切り離す
z_detached = z.detach()
print("detachしたTensorのrequires_grad:", z_detached.requires_grad)

x = torch.tensor(2.0, requires_grad=True)
y = x * x
z = y + 1.0
z.backward()
print("dz/dx =", x.grad.item())  # 2x で x=2 なら 4

arr = np.array([[1, 2], [3, 4]], dtype=np.float32)
tensor_from_np = torch.from_numpy(arr) # NumPy配列からTensorを作成

print("NumPy -> Tensor")
print(tensor_from_np)

back_to_np = tensor_from_np.numpy() # TensorからNumPy配列に変換
print("Tensor -> NumPy")
print(back_to_np)

# メモリ共有の確認
arr[0, 0] = 99
print("NumPy変更後のTensor:") # NumPy配列を変更するとTensorも変更される
print(tensor_from_np)

tensor_from_np[0, 1] = 88
print("Tensor変更後のNumPy:") # Tensorを変更するとNumPy配列も変更される
print(back_to_np)

# 1) 配列作成と形状変更（np.zeros / np.ones / np.arange / np.reshape に対応）
print("torch.zeros(5):", torch.zeros(5))
print("torch.ones((2, 3)):\n", torch.ones((2, 3)))
a = torch.arange(0, 10)
print("torch.arange(0, 10):", a)
print("torch.reshape(a, (2, 5)):\n", torch.reshape(a, (2, 5)))

u = torch.tensor([1.0, 2.0, 3.0])
v = torch.tensor([4.0, 5.0, 6.0])

print("u @ v (dot):", (u @ v).item())
print("torch.outer(u, v):\n", torch.outer(u, v))

x = torch.tensor([1.0, torch.e, torch.e**2])
print("torch.log(x):", torch.log(x))

y = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
print("torch.exp(y):", torch.exp(y))

angles_deg = torch.tensor([0.0, 30.0, 45.0, 60.0, 90.0])
angles_rad = torch.deg2rad(angles_deg)
print("torch.sin(angles_rad):", torch.sin(angles_rad))
print("torch.cos(angles_rad):", torch.cos(angles_rad))
print("torch.tan(angles_rad):", torch.tan(angles_rad))

z = torch.tensor([-1.8, -0.2, 0.0, 1.2, 3.9])
print("torch.floor(z):", torch.floor(z))

w = torch.tensor([0.0, float("nan"), 1.5, float("nan"), -3.0])
print("torch.isnan(w):", torch.isnan(w))
print("NaNを除いた要素:", w[~torch.isnan(w)])

X = torch.tensor([[0.5, 1.0, 2.0], [2.0, 2.5, 0.1]])

print("torch.sum(X):", torch.sum(X).item())
print("torch.sum(X, dim=0):", torch.sum(X, dim=0))
print("torch.sum(X, dim=1, keepdim=True):\n", torch.sum(X, dim=1, keepdim=True))

print("torch.min(X):", torch.min(X).item())
print("torch.max(X):", torch.max(X).item())
print("torch.argmax(X):", torch.argmax(X).item())
print("torch.argmin(X):", torch.argmin(X).item())

print("torch.mean(X):", torch.mean(X).item())
print("torch.var(X):", torch.var(X, unbiased=False).item())
print("torch.std(X):", torch.std(X, unbiased=False).item())

a = torch.arange(6).reshape(2, 3)
b = torch.tensor([10.0, 20.0, 30.0])
# bは最後の次元が一致するので行方向に足し込まれる
print("a shape:", a.shape, "b shape:", b.shape)
print("a + b:\n", a + b)

p = torch.tensor([[1.0, 2.0]])
q = torch.tensor([[3.0, 4.0]])
print("cat dim=0:\n", torch.cat([p, q], dim=0))
print("stack shape:", torch.stack([p.squeeze(0), q.squeeze(0)], dim=0).shape)

x_int = torch.tensor([1, 2, 3])
x_f = x_int.float()
print("dtype:", x_int.dtype, "->", x_f.dtype)

# 乱数シードを固定して、毎回同じ結果を再現できるようにする
torch.manual_seed(0)

# 入力データxを-1から1まで100点作る（形状は[100, 1]）
x_train = torch.linspace(-1, 1, 100).unsqueeze(1)
# 正規分布ノイズを作る（x_trainと同じ形状）
noise = 0.2 * torch.randn_like(x_train)
# 正解データyを y = 2.5x + 0.8 + ノイズ で作る
y_train = 2.5 * x_train + 0.8 + noise

# 重みwをランダム初期化し、勾配計算対象にする
w = torch.randn(1, requires_grad=True)
# バイアスbを0で初期化し、勾配計算対象にする
b = torch.zeros(1, requires_grad=True)

# 学習率（1回の更新幅）を設定する
lr = 0.1
# 全データを使った反復回数（エポック数）を設定する
epochs = 100

# エポック数だけ学習を繰り返す
for epoch in range(epochs):
    # 現在のw, bで予測値を計算する（順伝播）
    pred = w * x_train + b

    # 予測値と正解値の平均二乗誤差を計算する
    loss = ((pred - y_train) ** 2).mean()

    # lossをw, bで微分し、勾配を計算する（逆伝播）
    loss.backward()

    # 勾配追跡を無効にしてパラメータを更新する
    with torch.no_grad():
        # 重みwを勾配降下法で更新する
        w -= lr * w.grad
        # バイアスbを勾配降下法で更新する
        b -= lr * b.grad

    # 次のエポックのためにwの勾配を0に戻す
    w.grad.zero_()
    # 次のエポックのためにbの勾配を0に戻す
    b.grad.zero_()

    # 20エポックごとに損失を表示して学習の進み具合を確認する
    if epoch % 20 == 0:
        print(f"epoch={epoch:3d}, loss={loss.item():.4f}")

# 学習後の重みとバイアスを表示する
print(f"learned w={w.item():.3f}, b={b.item():.3f}")

class ScalarLinear(nn.Module):
    """y = w x + b の1次元回帰用の最小モデル"""

    def __init__(self) -> None:
        super().__init__()
        self.lin = nn.Linear(1, 1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.lin(x)


demo_model = ScalarLinear()
print(demo_model)

# 入力1次元・出力1次元の線形モデルを作る（内部に重みとバイアスを持つ）
model = nn.Linear(in_features=1, out_features=1)
# 回帰でよく使う平均二乗誤差を損失関数として定義する
criterion = nn.MSELoss()
# 確率的勾配降下法（SGD）でモデルのパラメータを更新する設定を行う
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 学習の反復回数を設定する
epochs = 100
# エポック数だけ学習を繰り返す
for epoch in range(epochs):
    # モデルに入力を渡して予測値を計算する（順伝播）
    pred = model(x_train)
    # 予測値と正解値から損失を計算する
    loss = criterion(pred, y_train)

    # 1つ前のエポックで計算した勾配をリセットする
    optimizer.zero_grad()
    # 現在の損失を用いて勾配を計算する
    loss.backward()
    # 計算した勾配を使ってパラメータを1ステップ更新する
    optimizer.step()

    # 20エポックごとに損失を表示して収束状況を確認する
    if epoch % 20 == 0:
        print(f"epoch={epoch:3d}, loss={loss.item():.4f}")

# 学習後の重みを取り出す
w2 = model.weight.item()
# 学習後のバイアスを取り出す
b2 = model.bias.item()
# 学習結果を表示する
print(f"learned w={w2:.3f}, b={b2:.3f}")

import torch.nn.functional as F

x_demo = torch.tensor([-1.0, 0.0, 1.0])

# torch.nn を使う例（モジュールとして利用）
relu_module = nn.ReLU()
print("nn.ReLU()      :", relu_module(x_demo))

# torch.nn.functional を使う例（関数として利用）
print("F.relu(x_demo) :", F.relu(x_demo))

# ほかの活性化関数の例
print("nn.Sigmoid()   :", nn.Sigmoid()(x_demo))
print("torch.sigmoid():", torch.sigmoid(x_demo))

# DataLoaderとTensorDatasetを使うためのユーティリティを読み込む
from torch.utils.data import DataLoader, TensorDataset

# 入力と正解を1つのデータセットとしてまとめる
dataset = TensorDataset(x_train, y_train)
# ミニバッチサイズ16、各エポックでシャッフルするローダーを作る
loader = DataLoader(dataset, batch_size=16, shuffle=True)

# 線形回帰モデルを作る
model = nn.Linear(1, 1)
# 損失関数に平均二乗誤差を使う
criterion = nn.MSELoss()
# 最適化アルゴリズムにSGDを使う
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 60エポック学習する
for epoch in range(60):
    # ミニバッチごとに学習を進める
    for xb, yb in loader:
        # ミニバッチ入力から予測を計算する
        pred = model(xb)
        # ミニバッチ単位で損失を計算する
        loss = criterion(pred, yb)

        # 前回計算した勾配を消去する
        optimizer.zero_grad()
        # 現在のミニバッチ損失から勾配を計算する
        loss.backward()
        # 勾配を使ってパラメータを更新する
        optimizer.step()

    # 15エポックごとに直近ミニバッチの損失を表示する
    if epoch % 15 == 0:
        print(f"epoch={epoch:3d}, last_batch_loss={loss.item():.4f}")

# 学習後の重みとバイアスを表示する
print(f"learned w={model.weight.item():.3f}, b={model.bias.item():.3f}")

class TinyMLPRegressor(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(1, 8),
            nn.ReLU(),
            nn.Linear(8, 1),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)


mlp = TinyMLPRegressor()
opt = torch.optim.Adam(mlp.parameters(), lr=0.05)
crit = nn.MSELoss()
for _ in range(200):
    pred = mlp(x_train)
    loss = crit(pred, y_train)
    opt.zero_grad()
    loss.backward()
    opt.step()
print("MLP final loss:", loss.item())

mlp.train()
assert mlp.training is True
mlp.eval()
assert mlp.training is False

with torch.no_grad():
    y_hat = mlp(x_train[:5])
print("推論（先頭5件）:", y_hat.squeeze().tolist())

device = "cuda" if torch.cuda.is_available() else "cpu"
model_cpu = nn.Linear(1, 1)
model_dev = model_cpu.to(device)
print("model device:", next(model_dev.parameters()).device)

m = nn.Linear(1, 1)
buf = m.state_dict()
print("state_dict keys:", list(buf.keys()))

torch.manual_seed(0)
t = torch.arange(12).reshape(3, 4)
# この下にコードを書き、t.sum().item() を求めよ（答えは問題文の欄にのみ記入）

torch.manual_seed(0)
t = torch.arange(12).reshape(3, 4)
# この下にコードを書き、t[2, 0].item() を求めよ

x = torch.tensor(3.0, requires_grad=True)
y = x ** 3 - 2 * x
y.backward()
# この下にコードを書き、x.grad を小数第1位に四捨五入した値を求めよ

import torch.nn.functional as F

x = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0])
# この下にコードを書き、torch.allclose(nn.ReLU()(x), F.relu(x)) の結果を求めよ

m = nn.Linear(1, 1, bias=False)
nn.init.constant_(m.weight, 2.0) # mの重みはランダムに初期化されているのだが，このコードで重みを2.0に固定している
# この下にコードを書き、m(torch.tensor([[3.0]])) を小数第1位に四捨五入した値を求めよ

a = torch.zeros(4, 1)
b = torch.ones(1, 5)
# この下にコードを書き、(a + b) の要素数 numel を求めよ

x = torch.tensor(1.0, requires_grad=True)
# この下に with torch.no_grad(): を使い z = x * 2 を計算し、z.requires_grad の値を求めよ

torch.manual_seed(7)
m, n, r = 8, 6, 2
W_true = torch.rand(m, r)
H_true = torch.rand(r, n)
V = W_true @ H_true

W = torch.rand(m, r, requires_grad=True)
H = torch.rand(r, n, requires_grad=True)

# TODO: オプティマイザを定義し、損失 mean((V - W @ H) ** 2) を 2000 ステップ最小化せよ。
# 各ステップの末尾で W.clamp_(0), H.clamp_(0) により非負制約を満たすこと。

mse = torch.mean((V - W @ H) ** 2).item()
print("再構成MSE:", mse)
print("正解条件( MSE < 0.05 ):", mse < 0.05)

torch.manual_seed(123)
n = 200
X = torch.cat(
    [
        torch.randn(n // 2, 2) + torch.tensor([2.0, 2.0]),
        torch.randn(n // 2, 2) - torch.tensor([2.0, 2.0]),
    ],
    dim=0,
)
y = torch.cat([torch.zeros(n // 2, 1), torch.ones(n // 2, 1)], dim=0)

model = nn.Linear(2, 1)
# TODO: BCEWithLogitsLoss と SGD(lr=0.5) を用い、500エポック学習せよ。

with torch.no_grad():
    logits = model(X)
    acc = ((logits > 0).float() == y).float().mean().item()
print("accuracy:", acc)
print("正解条件( acc >= 0.92 ):", acc >= 0.92)