<jupyter_start><jupyter_text>Chapter3 ニューラルネットワークの基本 3. 糖尿病の予後予測【サンプルコード】<jupyter_code># 必要なパッケージのインストール
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn
import torch.nn.functional as F
from torch import optim<jupyter_output><empty_output><jupyter_text>3.1. 糖尿病（Diabetes）データセット<jupyter_code># データセットのロード
diabetes = load_diabetes()
# データセットの説明
print(diabetes.DESCR)
# データフレームに変換
df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
# 1年後の進行度の追加
df['target'] = diabetes.target
print(df.head())
# 基本統計量の確認
print(df.describe())
# データセットの可視化
sns.pairplot(df, x_vars=diabetes.feature_names, y_vars='target')
plt.show()<jupyter_output><empty_output><jupyter_text>3.2. 前準備<jupyter_code># データセットの読み込み
diabetes = load_diabetes()
data = diabetes.data  # 特徴量
label = diabetes.target.reshape(-1, 1)  # 一年後の糖尿病の進行度

# データセットのサイズの確認
print("data size: {}".format(data.shape))
print("label size: {}".format(label.shape))<jupyter_output>data size: (442, 10)
label size: (442, 1)<jupyter_text>3.3. 訓練データとテストデータの用意<jupyter_code># 学習データとテストデータを分割
train_data, test_data, train_label, test_label = train_test_split(
    data, label, test_size=0.2)

# 学習データとテストデータのサイズの確認
print("train_data size: {}".format(len(train_data)))
print("test_data size: {}".format(len(test_data)))
print("train_label size: {}".format(len(train_label)))
print("test_label size: {}".format(len(test_label)))
# ndarrayをPyTorchのTensorに変換
train_x = torch.Tensor(train_data)
test_x = torch.Tensor(test_data)
train_y = torch.Tensor(train_label)  # torch.float32のデータ型に
test_y = torch.Tensor(test_label)  # torch.float32のデータ型に
# 特徴量とラベルを結合したデータセットを作成
train_dataset = TensorDataset(train_x, train_y)
test_dataset = TensorDataset(test_x, test_y)
# ミニバッチサイズを指定したデータローダーを作成
train_batch = DataLoader(
    dataset=train_dataset,  # データセットの指定
    batch_size=20,  # バッチサイズの指定
    shuffle=True,  # シャッフルするかどうかの指定
    num_workers=2)  # コアの数
test_batch = DataLoader(
    dataset=test_dataset,
    batch_size=20,
    shuffle=False,
    num_workers=2)

# ミニバッチデータセットの確認
for data, label in train_batch:
    print("batch data size: {}".format(data.size()))  # バッチの入力データサイズ
    print("batch label size: {}".format(label.size()))  # バッチのラベルサイズ
    break<jupyter_output>batch data size: torch.Size([20, 10])
batch label size: torch.Size([20, 1])<jupyter_text>3.4. ニューラルネットワークの定義<jupyter_code># ニューラルネットワークの定義
class Net(nn.Module):
    def __init__(self, D_in, H, D_out):
        super(Net, self).__init__()
        self.linear1 = nn.Linear(D_in, H)
        self.linear2 = nn.Linear(H, H)  # 追加
        self.linear3 = nn.Linear(H, D_out)
        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))  # 追加
        x = F.relu(self.linear2(x))  # 追加
        x = self.dropout(x)  # 追加
        x = self.linear3(x)
        return x
# ハイパーパラメータの定義
D_in = 10  # 入力次元: 10
H = 200  # 隠れ層次元: 200
D_out = 1  # 出力次元: 1
epoch = 100  # 学習回数: 100
# ネットワークのロード
# CPUとGPUどちらを使うかを指定
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
net = Net(D_in, H, D_out).to(device)
# デバイスの確認
print("Device: {}".format(device))<jupyter_output>Device: cuda<jupyter_text>3.5. 損失関数と最適化関数の定義<jupyter_code># 損失関数の定義
criterion = nn.MSELoss()  # 今回の損失関数（平均二乗誤差: MSE）
criterion2 = nn.L1Loss()  # 参考用（平均絶対誤差: MAE）

# 最適化関数の定義
optimizer = optim.Adam(net.parameters())<jupyter_output><empty_output><jupyter_text>3.6. 学習<jupyter_code># 損失を保存するリストを作成
train_loss_list = []  # 学習損失（MSE）
test_loss_list = []  # 評価損失（MSE）
train_mae_list = []  # 学習MAE
test_mae_list = []  # 評価MAE

# 学習（エポック）の実行
for i in range(epoch):
    # エポックの進行状況を表示
    print('---------------------------------------------')
    print("Epoch: {}/{}".format(i+1, epoch))

    # 損失の初期化
    train_loss = 0  # 学習損失（MSE）
    test_loss = 0  # 評価損失（MSE）
    train_mae = 0  # 学習MAE
    test_mae = 0  # 評価MAE

    # ---------学習パート--------- #
    # ニューラルネットワークを学習モードに設定
    net.train()
    # ミニバッチごとにデータをロードし学習
    for data, label in train_batch:
        # GPUにTensorを転送
        data = data.to(device)
        label = label.to(device)

        # 勾配を初期化
        optimizer.zero_grad()
        # データを入力して予測値を計算（順伝播）
        y_pred = net(data)
        # 損失（誤差）を計算
        loss = criterion(y_pred, label)  # MSE
        mae = criterion2(y_pred, label)  # MAE
        # 勾配の計算（逆伝搬）
        loss.backward()
        # パラメータ（重み）の更新
        optimizer.step()
        # ミニバッチごとの損失を蓄積
        train_loss += loss.item()  # MSE
        train_mae += mae.item()  # MAE

    # ミニバッチの平均の損失を計算
    batch_train_loss = train_loss / len(train_batch)
    batch_train_mae = train_mae / len(train_batch)
    # ---------学習パートはここまで--------- #

    # ---------評価パート--------- #
    # ニューラルネットワークを評価モードに設定
    net.eval()
    # 評価時の計算で自動微分機能をオフにする
    with torch.no_grad():
        for data, label in test_batch:
            # GPUにTensorを転送
            data = data.to(device)
            label = label.to(device)
            # データを入力して予測値を計算（順伝播）
            y_pred = net(data)
            # 損失（誤差）を計算
            loss = criterion(y_pred, label)  # MSE
            mae = criterion2(y_pred, label)  # MAE
            # ミニバッチごとの損失を蓄積
            test_loss += loss.item()  # MSE
            test_mae += mae.item()  # MAE

    # ミニバッチの平均の損失を計算
    batch_test_loss = test_loss / len(test_batch)
    batch_test_mae = test_mae / len(test_batch)
    # ---------評価パートはここまで--------- #

    # エポックごとに損失を表示
    print("Train_Loss: {:.4f} Train_MAE: {:.4f}".format(
        batch_train_loss, batch_train_mae))
    print("Test_Loss: {:.4f} Test_MAE: {:.4f}".format(
        batch_test_loss, batch_test_mae))
    # 損失をリスト化して保存
    train_loss_list.append(batch_train_loss)
    test_loss_list.append(batch_test_loss)
    train_mae_list.append(batch_train_mae)
    test_mae_list.append(batch_test_mae)<jupyter_output>---------------------------------------------
Epoch: 1/100
Train_Loss: 27942.0368 Train_MAE: 148.6651
Test_Loss: 33273.5137 Test_MAE: 164.6294
---------------------------------------------
Epoch: 2/100
Train_Loss: 26105.5414 Train_MAE: 142.5335
Test_Loss: 28511.5438 Test_MAE: 149.6040
---------------------------------------------
Epoch: 3/100
Train_Loss: 17815.0728 Train_MAE: 109.6373
Test_Loss: 13448.1678 Test_MAE: 90.1616
---------------------------------------------
Epoch: 4/100
Train_Loss: 6515.6198 Train_MAE: 65.0283
Test_Loss: 5256.7317 Test_MAE: 63.7509
---------------------------------------------
Epoch: 5/100
Train_Loss: 5325.7048 Train_MAE: 62.2058
Test_Loss: 5344.3022 Test_MAE: 60.0377
---------------------------------------------
Epoch: 6/100
Train_Loss: 5093.5105 Train_MAE: 59.6543
Test_Loss: 4659.7018 Test_MAE: 57.2663
---------------------------------------------
Epoch: 7/100
Train_Loss: 4850.5950 Train_MAE: 58.6890
Test_Loss: 4515.0340 Test_MAE: 55.7729
----------------[...]<jupyter_text>3.7. 結果の可視化<jupyter_code># 損失（MSE）
plt.figure()
plt.title('Train and Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.plot(range(1, epoch+1), train_loss_list, color='blue',
         linestyle='-', label='Train_Loss')
plt.plot(range(1, epoch+1), test_loss_list, color='red',
         linestyle='--', label='Test_Loss')
plt.legend()  # 凡例

# MAE
plt.figure()
plt.title('Train and Test MAE')
plt.xlabel('Epoch')
plt.ylabel('MAE')
plt.plot(range(1, epoch+1), train_mae_list, color='blue',
         linestyle='-', label='Train_MAE')
plt.plot(range(1, epoch+1), test_mae_list, color='red',
         linestyle='--', label='Test_MAE')
plt.legend()  # 凡例

# 表示
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.18152454780361757, 'fraction_numerical': 0.04263565891472868, 'mean_word_length': 2.9454638124362895, 'pattern_counts': {'":': 0, '<': 29, '<?xml version=': 0, '>': 29, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '15104', 'license': 'MIT', 'n_tokens_mistral': 3902, 'n_tokens_neox': 3648, 'n_words': 520, 'path': 'Ubuntu/Chapter3/Section3-3.ipynb', 'repo_name': 'Hexans/pytorchbook_samplecode', 'size': '7740'}