デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



model = SimpleNN(input_size=X.shape[1])

momentum_optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

momentum_losses = train_model(model, momentum_optimizer)

plot_losses(momentum_losses, "Momentum Optimizer")

デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



model = SimpleNN(input_size=X.shape[1])

adagrad_optimizer = optim.Adagrad(model.parameters(), lr=0.001)

adagrad_losses = train_model(model, adagrad_optimizer)

plot_losses(adagrad_losses, "Adagrad Optimizer")

デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



model = SimpleNN(input_size=X.shape[1])

rmsprop_optimizer = optim.RMSprop(model.parameters(), lr=0.001)

rmsprop_losses = train_model(model, rmsprop_optimizer)

plot_losses(rmsprop_losses, "RMSProp Optimizer")

デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



model = SimpleNN(input_size=X.shape[1])

adam_optimizer = optim.Adam(model.parameters(), lr=0.001)

adam_losses = train_model(model, adam_optimizer)

plot_losses(adam_losses, "Adam Optimizer")

デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



# AdamW最適化手法によるトレーニングと損失のプロット

model = SimpleNN(input_size=X.shape[1])

adamw_optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-4)

adamw_losses = train_model(model, adamw_optimizer)

plot_losses(adamw_losses, "AdamW Optimizer")

デフォルトのコード

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

import time



# データセットの準備

data = load_breast_cancer()

X = data.data

y = data.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.tensor(X_train, dtype=torch.float32)

y_train = torch.tensor(y_train, dtype=torch.long)

X_test = torch.tensor(X_test, dtype=torch.float32)

y_test = torch.tensor(y_test, dtype=torch.long)



train_dataset = TensorDataset(X_train, y_train)

test_dataset = TensorDataset(X_test, y_test)



train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)



# モデルの定義

class SimpleNN(nn.Module):

    def __init__(self, input_size):

        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 64)

        self.fc3 = nn.Linear(64, 2)  # 2クラス分類



    def forward(self, x):

        x = torch.relu(self.fc1(x))

        x = torch.relu(self.fc2(x))

        x = self.fc3(x)

        return x



def train_model(model, optimizer, num_epochs=40):

    criterion = nn.CrossEntropyLoss()

    model.train()

    loss_list = []
    for epoch in range(num_epochs):

        running_loss = 0.0

        start_epoch_time = time.time()

        for data, target in train_loader:

            data, target = data, target

            

            optimizer.zero_grad()

            outputs = model(data)

            loss = criterion(outputs, target)

            loss.backward()

            optimizer.step()

            

            running_loss += loss.item()

        

        epoch_loss = running_loss / len(train_loader)

        loss_list.append(epoch_loss)

        end_epoch_time = time.time()

    

    return loss_list



def plot_losses(losses, title):

    plt.plot(losses, label=title)

    plt.xlabel('Epoch')

    plt.ylabel('Loss')

    plt.legend()

    plt.title(title)

    plt.show()



# AMSGrad最適化手法によるトレーニングと損失のプロット

model = SimpleNN(input_size=X.shape[1])

amsgrad_optimizer = optim.Adam(model.parameters(), lr=0.001, amsgrad=True)

amsgrad_losses = train_model(model, amsgrad_optimizer)

plot_losses(amsgrad_losses, "AMSGrad Optimizer")