デフォルトのコード

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.sigmoid(self.fc1(x))

        x = torch.sigmoid(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クラス分類



        # Kaiming初期化（He初期化）を適用

        nn.init.kaiming_normal_(self.fc1.weight, nonlinearity='relu')

        nn.init.kaiming_normal_(self.fc2.weight, nonlinearity='relu')

        nn.init.kaiming_normal_(self.fc3.weight, nonlinearity='relu')



    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])

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")