ニューラルネットワークと機械学習の基礎：概念からPyTorchによる実装まで

import torch
from torch import nn, optim
from torchvision import datasets, transforms

# デバイスの設定
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# データセットの準備（MNIST）
transform = transforms.Compose([transforms.ToTensor()])
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# データローダーの設定
train_loader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=64, shuffle=False)

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# モデルをデバイスに移動
model = SimpleNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 学習の実行
epochs = 5
for epoch in range(epochs):
    model.train()  # 訓練モードの設定
    running_loss = 0.0
    for images, labels in train_loader:
        # データをデバイスに移動
        images = images.view(images.shape[0], -1).to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        output = model(images)
        loss = criterion(output, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        # メモリ解放
        del loss
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

    print(f"エポック {epoch+1}/{epochs}, 訓練損失: {running_loss/len(train_loader):.4f}")

# モデルの評価
model.eval()  # 評価モードの設定
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_loader:
        images = images.view(images.shape[0], -1).to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"テストデータにおける正解率: {100 * correct / total:.2f}%")

# ニューラルネットワークの単一ニューロンの順伝播計算
# 入力、重み、バイアスから活性化値を計算

# 入力値
inputs = [0.3, -0.5, 0.2]
# 重み
weights = [0.1, 0.8, -0.5]
# バイアス
bias = 0.2

# 重み付き和の計算
weighted_sum = 0
# 各入力に対応する重みを掛けて合計
for i in range(len(inputs)):
    weighted_sum += inputs[i] * weights[i]

# バイアスを加える
weighted_sum += bias

# ReLU活性化関数による出力計算
# 0以下の場合は0、そうでなければweighted_sumをそのまま出力
if weighted_sum > 0:
    output = weighted_sum
else:
    output = 0

# 結果を表示
print(f"{inputs} -> {output}")

import math

def relu(x):
   """
   ReLU活性化関数
   入力が0より大きい場合はそのまま返し、0以下の場合は0を返す
   """
   return max(0, x)

def sigmoid(x):
   """
   シグモイド活性化関数
   入力を0-1の範囲に変換する
   """
   return 1 / (1 + math.exp(-x))

# 入力値の設定
x1 = 1
x2 = -1
x3 = 0

# ReLU関数による出力計算
relu_out1 = relu(x1)
relu_out2 = relu(x2)

# シグモイド関数による出力計算
sigmoid_out = sigmoid(x3)

# 結果の表示
print(f"{x1} -> {relu_out1}")  # 正の入力
print(f"{x2} -> {relu_out2}")  # 負の入力
print(f"{x3} -> {sigmoid_out}")  # シグモイド

# ニューラルネットワークによる3クラス分類の実装
# 入力層(2ニューロン)から出力層(3ニューロン)への順伝播計算を行う

inputs = [0.2, 0.8]  # 入力値

# 入力層から出力層への重み係数(2×3行列)
layer_weights = [
   [0.1, 0.4, 0.7],  # 入力1からの重み
   [0.2, 0.5, 0.8]   # 入力2からの重み
]

layer_bias = [0.1, 0.1, 0.1]  # 出力層の各ニューロンのバイアス

# 出力層の各ニューロンの出力を計算
output = [0] * 3  # 出力用配列を初期化
for j in range(3):  # 出力層の各ニューロンについて
   sum = 0
   for i in range(2):  # 入力層の各ニューロンからの入力を合計
       sum += inputs[i] * layer_weights[i][j]
   sum += layer_bias[j]  # バイアスを加算
   output[j] = max(0, sum)  # ReLU関数による活性化

print(f"入力: {inputs}")
print(f"出力: {output}")
print(f"分類結果: {output.index(max(output))}")  # 最大出力を持つニューロンのインデックスを取得

# ニューラルネットワークの3クラス分類プログラム
import torch

# 入力データ（2個のニューロン）
inputs = torch.tensor([0.2, 0.8])

# 重み行列（入力2×出力3の行列、転置して使用）
layer_weights = torch.tensor([
   [0.1, 0.4, 0.7],  # 1番目の入力からの重み
   [0.2, 0.5, 0.8]   # 2番目の入力からの重み
]).T  # 行列を転置して各出力ニューロンへの重みを行方向に配置

# バイアス（出力層の3ニューロン分）
layer_bias = torch.tensor([0.1, 0.1, 0.1])

# フォワードプロパゲーション
# 1. 入力と重みの行列積で重み付き和を計算
# 2. バイアスを加算
# 3. ReLU関数で活性化（max(0,x)）
output = torch.relu(torch.matmul(inputs, layer_weights.T) + layer_bias)

# 結果出力
print(f"入力: {inputs.tolist()}")
print(f"出力: {output.tolist()}")
print(f"分類結果: {torch.argmax(output).item()}")  # 最大値を持つインデックスが分類結果

"""
ニューラルネットワークの学習実装
入力層(2)→出力層(3)の順伝播型ネットワーク
ReLU活性化関数を使用し、二乗誤差による学習を行う
"""

inputs = [0.2, 0.8]
target = [1, 0, 0]  # 正解ラベル（3クラス分類の1番目）
learning_rate = 0.1

# 初期重みとバイアス
layer_weights = [
   [0.1, 0.4, 0.7],  # 入力1から各出力への重み
   [0.2, 0.5, 0.8]   # 入力2から各出力への重み
]
layer_bias = [0.1, 0.1, 0.1]  # 各出力ノードのバイアス

# フォワード計算：入力値と重みの積和にバイアスを加え、ReLU関数で活性化
output = [0, 0, 0]
for j in range(3):  # 各出力ノードについて
   sum = 0
   for i in range(2):  # 各入力との重み付き和を計算
       sum += inputs[i] * layer_weights[i][j]
   sum += layer_bias[j]
   output[j] = max(0, sum)  # ReLU関数による活性化

# 誤差計算：教師信号と出力の差
errors = [target[j] - output[j] for j in range(3)]

# 重みとバイアスの更新：勾配降下法による調整
for j in range(3):
   for i in range(2):
       if output[j] > 0:  # ReLUの勾配は出力が正の時のみ1
           layer_weights[i][j] += learning_rate * errors[j] * inputs[i]
   if output[j] > 0:  # バイアスも同様に更新
       layer_bias[j] += learning_rate * errors[j]

print(f"誤差: {errors}")
print(f"更新後の重み: {layer_weights}")

import torch

# 入力データと教師信号の設定
inputs = torch.tensor([0.2, 0.8], requires_grad=True)
target = torch.tensor([1.0, 0.0, 0.0])  # 3クラス分類の正解ラベル
learning_rate = 0.1  # 学習率

# 重みとバイアスの初期化（requires_gradを設定して勾配計算を有効化）
layer_weights = torch.tensor([
   [0.1, 0.4, 0.7],
   [0.2, 0.5, 0.8]
], requires_grad=True)
layer_bias = torch.tensor([0.1, 0.1, 0.1], requires_grad=True)

# フォワード計算：入力値と重みの行列積にバイアスを加算し、ReLU関数で活性化
output = torch.relu(torch.matmul(inputs, layer_weights) + layer_bias)

# 二乗誤差による損失計算
loss = torch.sum((target - output) ** 2)

# 誤差逆伝播による勾配計算
loss.backward()

# 勾配降下法による重みとバイアスの更新
with torch.no_grad():  # 更新時は勾配計算不要
   layer_weights -= learning_rate * layer_weights.grad
   layer_bias -= learning_rate * layer_bias.grad

   # 次回の学習のために勾配をクリア
   layer_weights.grad.zero_()
   layer_bias.grad.zero_()

# 学習結果の出力
print(f"誤差: {(target - output).tolist()}")
print(f"更新後の重み: {layer_weights.tolist()}")