学習

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda, Compose
import matplotlib.pyplot as plt

# サンプルデータ準備、あらかじめ用意されているデータを利用。
#Iris Dataset：あやめ（花びら／がく片の長さと幅の4項目）の表形式データセット
from sklearn.datasets import load_iris
iris = load_iris()
# 入力値xと目標値tを抽出
x=iris['data']
t=iris['target']
# PytorchのTensor型へ変換
x=torch.tensor(x,dtype=torch.float32)#少数に設定
t=torch.tensor(t,dtype=torch.int64)#整数に設定
# 入力値と目標値をまとめる
dataset=torch.utils.data.TensorDataset(x,t)
# データセット分割、datasetを分割
#学習データ、テストデータを用意する。
# 各データのサンプル数を決定する
# training:test=80%:20%
n_train=int(len(dataset)*0.8)
n_test=int(len(dataset)*0.2)
# データセット150個の分割,ランダムに分割
training_data,test_data=torch.utils.data.random_split(dataset,[n_train,n_test])

batch_size = 10#バッチサイズは少なくした
# データローダーの作成
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

# 訓練に際して、可能であればGPU（cuda）を設定します。GPUが搭載されていない場合はCPUを使用します
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
# modelを定義します
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        # self.flatten = nn.Flatten()#nn.Flattenレイヤーで、2次元（28x28）の画像を、1次元の784ピクセルの値へと変換するもの。今回は関係ない。
        # nn.Sequentialは、モジュールを順番に格納する箱のような要素です。
        # 入力データはnn.Sequentialに定義された順番に各モジュールを伝搬します。
        self.linear_relu_stack = nn.Sequential(
#*******このモデルを「あやめ」にあてはめてやった（4入力3出力）が、成績が良くないので使わない。*****
            # nn.Linear(28*28, 512),#入力データが28*28の画像データなので28*28入力ノードが必要でした。
            # nn.ReLU(),
            # nn.Linear(512, 512),
            # nn.ReLU(),
            # nn.Linear(512, 10),#出力10種類なので10
            # nn.ReLU()
#*********************************************************************
#********あやめ用の正解率のいいモデルを使う***********
            #Irisの特徴量(がく片の長さ、がく片の幅、花びらの長さ、花びらの幅）が4個で1組なのでノード4

            nn.Linear(4,6),#入力条件4個なので4。2層目の6は変えてもいい。
            nn.Sigmoid(),
            nn.Linear(6,3)#あやめ3種類の判別なのでノード
#**********************************************************************
         )
    def forward(self, x):
        # x = self.flatten(x)#今回二次元画像ではないので関係ない。
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)

loss_fn = nn.CrossEntropyLoss()
# optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)#lr学習係数0.001だと正解率低くなるので0.1にした。
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        X, y = X.to(device), y.to(device)
        
        # 損失誤差を計算
        pred = model(X)
        loss = loss_fn(pred, y)
        
        # バックプロパゲーション
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # if batch % 100 == 0:#バッチ数が少ないので全部表示
        loss, current = loss.item(), batch * len(X)
        print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

def test(dataloader, model):
    size = len(dataloader.dataset)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

epochs = 200#training全データセット120個をepoxhs回学習
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model)
print("Done!")

torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")

model = NeuralNetwork()
model.load_state_dict(torch.load("model.pth"))