サンプルコード集 (Pytorch) | mei

◯こちらのサンプルコードは指導等にご自由にお使いください。

【サンプルコードの使い方】
◯サンプルコードを写す時はコピペをしないようにしましょう。
◯▶を押すと出力が表示されます。
◯Geminiボタンを押すとGemini(AI)による解説が表示されます。間違っていることもあるので、疑問に思った場合はご質問ください。
◯本マークを押すとカテゴリーの解説が見られます。

【カテゴリーごとのページへ移動】

【Code List】

すべて見る

CODE: m-1 (Pytorch)
CODE: m-2 (Pytorch)
CODE: m-3 (Pytorch)

CODE: m-1 (Pytorch)



import os
os.environ['OMP_NUM_THREADS'] = '1'
os.environ['MKL_NUM_THREADS'] = '1'

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler


NUM_EPOCH = 30


def create_nn_model():
    model = nn.Sequential(
        nn.Linear(4, 16),
        nn.ReLU(),
        nn.Linear(16, 8),
        nn.ReLU(),
        nn.Linear(8, 3)
    )
    return(model)


def main():

    # ---- (1) データの取得 ----

    iris = load_iris()
    X, y = iris.data, iris.target
    
    scaler = StandardScaler()
    X = scaler.fit_transform(X)
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    X_train = torch.FloatTensor(X_train)
    X_test = torch.FloatTensor(X_test)
    y_train = torch.LongTensor(y_train)
    y_test = torch.LongTensor(y_test)

    # ---- (2) モデル作成 ----
    
    model = create_nn_model()                               # 全体的なモデル
    criterion = nn.CrossEntropyLoss()                       # 評価関数
    optimizer = optim.Adam(model.parameters(), lr=0.01)     # 最適化手法

    # ---- (3) 学習 ----
    
    epochs = NUM_EPOCH
    for epoch in range(epochs):
        optimizer.zero_grad()
        outputs = model(X_train)
        loss = criterion(outputs, y_train)
        loss.backward()
        optimizer.step()
        print(f"Epoch: {epoch+1} Loss: {loss.item()}")

    # ---- (4) 評価 ----
        
    model.eval()
    with torch.no_grad():
        test_outputs = model(X_test)
        _, predicted = torch.max(test_outputs, 1)
        accuracy = (predicted == y_test).sum().item() / y_test.size(0)
        print(f"Accuracy: {accuracy}")

    return(0)


main()

(1) データの取得 -> (2) モデル作成 -> (3) 学習 -> (4) 評価の流れはどのニューラルネットワークでも同じ。
create_nn_model()で、NNモデルを作成。今回は(4-16-8-3)の4層。
torch.FloatTensor()によって、データをpytorchに適した形に変更する。
torch.max()によって、最も出力の高いノードを割り出している。

CODE: m-2 (Pytorch)



import os
os.environ['OMP_NUM_THREADS'] = '1'
os.environ['MKL_NUM_THREADS'] = '1'

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt


NUM_EPOCH = 10
BATCH_SIZE = 64


def create_lenet():
    model = nn.Sequential(
        nn.Conv2d(3, 6, 5),
        nn.ReLU(),
        nn.MaxPool2d(2, 2),
        nn.Conv2d(6, 16, 5),
        nn.ReLU(),
        nn.MaxPool2d(2, 2),
        nn.Flatten(),
        nn.Linear(16 * 5 * 5, 120),
        nn.ReLU(),
        nn.Linear(120, 84),
        nn.ReLU(),
        nn.Linear(84, 10)
    )
    return(model)


def main():

    # ---- (1) データの取得 ----

    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])

    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0)

    testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=BATCH_SIZE, shuffle=False, num_workers=0)

    # ---- (2) モデル作成 ----

    device = torch.device("cpu")
    model = create_lenet().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # ---- (3) 学習 ----

    epochs = NUM_EPOCH 
    history = {'loss': [], 'acc': []}

    for epoch in range(epochs):
        model.train()
        running_loss = 0.0
        
        for inputs, labels in trainloader:
            inputs, labels = inputs.to(device), labels.to(device)
            
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
        epoch_loss = running_loss / len(trainloader)
        print(f"Epoch [{epoch+1}], Loss: {epoch_loss}")

    # ---- (4) 評価 ----

    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in testloader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print(f"Accuracy: {correct / total}")

    return(0)
	

main()

今回はLeNetによる古典的なCNNを実装している。
データはCIFAR-10を使用。
m-1と異なり、データの数が多いためバッチ学習を用いている。

CODE: m-3 (Pytorch)




import os
os.environ['OMP_NUM_THREADS'] = '1'
os.environ['MKL_NUM_THREADS'] = '1'

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt


NUM_EPOCH = 50
HIDDEN_SIZE = 50


def create_data(seq_len=50):
    x = np.linspace(0, 100, 1000)
    y = np.sin(x)
    
    data = []
    target = []
    for i in range(len(y) - seq_len):
        data.append(y[i:i+seq_len])
        target.append(y[i+seq_len])
        
    data = torch.FloatTensor(np.array(data)).unsqueeze(-1)
    target = torch.FloatTensor(np.array(target)).unsqueeze(-1)
    return data, target


def main():
	
    # ---- (1) データの取得 ----

    seq_len = 50
    (data, target) = create_data(seq_len)
    
    train_size = int(len(data) * 0.8)
    x_train, x_test = data[:train_size], data[train_size:]
    y_train, y_test = target[:train_size], target[train_size:]

    # ---- (2) モデルの作成 ----

    model = nn.Sequential(
        nn.LSTM(input_size=1, hidden_size=HIDDEN_SIZE, num_layers=1, batch_first=True),
    )
    fc = nn.Linear(HIDDEN_SIZE, 1)
    criterion = nn.MSELoss()
    optimizer = optim.Adam(list(model.parameters()) + list(fc.parameters()), lr=0.01)

    # ---- (3) 学習 ----

    epochs = NUM_EPOCH
    for epoch in range(epochs):
        model.train()
        optimizer.zero_grad()
        
        lstm_out, _ = model(x_train)
        last_out = lstm_out[:, -1, :]
        outputs = fc(last_out)
        
        loss = criterion(outputs, y_train)
        loss.backward()
        optimizer.step()

        print(f"Epoch {epoch+1}, Loss: {loss.item()}")

    # ---- (4) 評価 ----

    model.eval()
    with torch.no_grad():
        test_lstm_out, _ = model(x_test)
        predictions = fc(test_lstm_out[:, -1, :])

    plt.figure(figsize=(10, 5))
    plt.plot(y_test.numpy(), label='True')
    plt.plot(predictions.numpy(), label='Predicted')
    plt.legend()
    plt.savefig("m-3.png")

    return(0)

main()

LSTMは、nn.LSTM()で簡単にモデルを作ることができる。
LSTMは(バッチサイズ、シーケンス長、入力次元数)の形状を入力する必要があるため、unsqueez(-1)で次元を調整している。
出力ファイル1

初心者から始められるPythonレッスン

● プログラミング未経験者・初心者歓迎！
● 月額4,000円で質問し放題!!
● 完全オンライン
● 翌日までには必ず返信
● 挫折しない独自の学習メソッド
● 圧倒的高評価!!
● テキストベースで時間を選ばない
● 高品質なサンプルコード
詳細はこちら
興味がある方はまず質問だけでもどうぞ!