2023年2月16日 - 流行の科学技術を勝手に追いかけるブログ人工知能仮想現実ブロックチェーン

多層パーセプトロンで近似してみます

モジュール

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
%matplotlib inline

import torch

import torch.nn as nn

import torch.optim as optim

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from torchvision import datasets, transforms

from torch.utils.data import DataLoader

%matplotlib inline

# GPUが使えるかどうか確認する
device = "cuda" if torch.cuda.is_available() else 'cpu'
device
'cuda'
# データを呼び出す
transform = transforms.Compose([transforms.ToTensor()])
     # 画像をtensorに変換する。channel firstへ変換。0-1へ変換。    

train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_dataset
Dataset MNIST
    Number of datapoints: 60000
    Root location: ./data
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
           )
# バッチサイズを定義する　（バッチサイズと言ったら　ミニバッチのサイズのことを指す。データ全数のことではない）
num_batches = 100 

# データセットからバッチサイズ分を抽出する。
train_dataloader = DataLoader(train_dataset, batch_size=num_batches, shuffle=True)
train_iter = iter(train_dataloader)
imgs, labels = next(train_iter)
imgs, labels
imgs.size() # torch.Size([100, 1, 28, 28]) 　チャネルファースト１００データ,モノクロ１行,（縦２８x横２８）
torch.Size([100, 1, 28, 28])
# 教師データの確認
labels
tensor([1, 7, 9, 9, 6, 3, 4, 0, 2, 8, 4, 3, 4, 1, 5, 7, 6, 6, 8, 8, 6, 7, 9, 3,
        6, 2, 7, 3, 2, 6, 5, 2, 8, 7, 0, 4, 1, 4, 6, 5, 6, 9, 8, 9, 8, 3, 1, 2,
        4, 6, 9, 4, 8, 1, 7, 4, 7, 4, 5, 7, 8, 5, 4, 2, 5, 1, 8, 3, 6, 8, 1, 8,
        9, 9, 6, 6, 7, 4, 8, 8, 1, 3, 7, 6, 4, 5, 5, 9, 4, 1, 0, 5, 6, 8, 6, 9,
        3, 5, 3, 2])
#イメージデータ　０番目の確認
img = imgs[0] # torch.Size([0番目, 1, 28, 28]) 　チャネルファースト１００データ,モノクロ１行,（縦２８x横２８）
print(img.size()) # torch.Size([1, 28, 28])
img
torch.Size([1, 28, 28])
tensor([[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,

     0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000],
         [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
          0.0000, 0.0000, 0.0000, 0.0000]]])
# permuteでチャネルファーストをやめて　縦x横xch　へからを入れ替える
img_permute = img.permute(1,2,0) 
print(img_permute.size()) # torch.Size([28, 28, 1])
img_permute
torch.Size([28, 28, 1])
tensor([[[0.0000],
         [0.0000],
         [0.0000],
         [0.0000],
         [0.0000],
         [0.0000],

# GPUが使えるかどうか確認する

device = "cuda" if torch.cuda.is_available() else 'cpu'

device

'cuda'

# データを呼び出す

transform = transforms.Compose([transforms.ToTensor()])

# 画像をtensorに変換する。channel firstへ変換。0-1へ変換。

train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)

train_dataset

Dataset MNIST

Number of datapoints: 60000

Root location: ./data

Split: Train

StandardTransform

Transform: Compose(

ToTensor()

)

# バッチサイズを定義する　（バッチサイズと言ったら　ミニバッチのサイズのことを指す。データ全数のことではない）

num_batches = 100

# データセットからバッチサイズ分を抽出する。

train_dataloader = DataLoader(train_dataset, batch_size=num_batches, shuffle=True)

train_iter = iter(train_dataloader)

imgs, labels = next(train_iter)

imgs, labels

imgs.size() # torch.Size([100, 1, 28, 28]) 　チャネルファースト１００データ,モノクロ１行,（縦２８x横２８）

torch.Size([100, 1, 28, 28])

# 教師データの確認

labels

tensor([1, 7, 9, 9, 6, 3, 4, 0, 2, 8, 4, 3, 4, 1, 5, 7, 6, 6, 8, 8, 6, 7, 9, 3,

6, 2, 7, 3, 2, 6, 5, 2, 8, 7, 0, 4, 1, 4, 6, 5, 6, 9, 8, 9, 8, 3, 1, 2,

4, 6, 9, 4, 8, 1, 7, 4, 7, 4, 5, 7, 8, 5, 4, 2, 5, 1, 8, 3, 6, 8, 1, 8,

9, 9, 6, 6, 7, 4, 8, 8, 1, 3, 7, 6, 4, 5, 5, 9, 4, 1, 0, 5, 6, 8, 6, 9,

3, 5, 3, 2])

#イメージデータ　０番目の確認

img = imgs[0] # torch.Size([0番目, 1, 28, 28]) 　チャネルファースト１００データ,モノクロ１行,（縦２８x横２８）

print(img.size()) # torch.Size([1, 28, 28])

img

torch.Size([1, 28, 28])

tensor([[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,

0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,

0.0000, 0.0000, 0.0000, 0.0000],

[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,

0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,

0.0000, 0.0000, 0.0000, 0.0000]]])

# permuteでチャネルファーストをやめて　縦x横xch　へからを入れ替える

img_permute = img.permute(1,2,0)

print(img_permute.size()) # torch.Size([28, 28, 1])

img_permute

torch.Size([28, 28, 1])

tensor([[[0.0000],

[0.0000],

# sns.heatmapで描画　numpy化が必要
sns.heatmap(img_permute.numpy()[:,:,0])

# 教師データ
print(labels[0])

# sns.heatmapで描画　numpy化が必要

sns.heatmap(img_permute.numpy()[:,:,0])

# 教師データ

print(labels[0])

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.classifier = nn.Sequential(
            nn.Linear(28*28, 400), 
            nn.ReLU(inplace=True),# inplace:元の配列をReLUによって書き換える：元の配列を保持しないのでメモリーが節約できる
            nn.Linear(400, 200),
            nn.ReLU(inplace=True),
            nn.Linear(200, 100),
            nn.ReLU(inplace=True),
            nn.Linear(100, 10)
        )
        
    def forward(self, x):
        output = self.classifier(x)
        return output

class MLP(nn.Module):

def __init__(self):

super().__init__()

self.classifier = nn.Sequential(

nn.Linear(28*28, 400),

nn.ReLU(inplace=True),# inplace:元の配列をReLUによって書き換える：元の配列を保持しないのでメモリーが節約できる

nn.Linear(400, 200),

nn.ReLU(inplace=True),

nn.Linear(200, 100),

nn.ReLU(inplace=True),

nn.Linear(100, 10)

)

def forward(self, x):

output = self.classifier(x)

return output

#MLPのインスタンスを作成する
model = MLP()

# modelをGPU上に送る
model.to(device)
MLP(
  (classifier): Sequential(
    (0): Linear(in_features=784, out_features=400, bias=True)
    (1): ReLU(inplace=True)
    (2): Linear(in_features=400, out_features=200, bias=True)
    (3): ReLU(inplace=True)
    (4): Linear(in_features=200, out_features=100, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=100, out_features=10, bias=True)
  )
)
criterion = nn.CrossEntropyLoss() # 多クラス分類
optimizer = optim.Adam(model.parameters(), lr=0.001) # オプティマイザー
"""
バッチ学習：全データを一気に学習する
ミニバッチ学習：全データから無作為に抽出して、複数回に分けて学習する
"""

num_epochs = 10 # 何回繰り返すか

losses = [] #損失
accs = []  #精度

for epoch in range(num_epochs):
    running_loss = 0.0 # 損失の初期化
    running_acc = 0.0  # 精度の初期化
    
    for imgs, labels in train_dataloader:
        imgs = imgs.view(num_batches, -1) # １次元ベクトルへ変換
        
        imgs = imgs.to(device)    # GPU上へ送る
        labels =labels.to(device) # GPU上へ送る
        
        optimizer.zero_grad() # 勾配の初期化
        output = model(imgs)  # モデル順伝播計算
        loss = criterion(output, labels)
        running_loss += loss.item()
        pred = torch.argmax(output, dim=1) # dim=0はバッチ方向　dim=1 は分類方向
        running_acc += torch.mean(pred.eq(labels).float())
        loss.backward() # 誤差　逆伝搬計算
        optimizer.step() # オプティマイザによるパラメータ更新
    
    running_loss /= len(train_dataloader)
    running_acc /= len(train_dataloader)
    
    losses.append(running_loss)
    accs.append(running_acc)
    
    print(f'epoch : {epoch}, loss {running_loss}: ,acc : {running_acc}')

#MLPのインスタンスを作成する

model = MLP()

# modelをGPU上に送る

model.to(device)

MLP(

(classifier): Sequential(

(0): Linear(in_features=784, out_features=400, bias=True)

(1): ReLU(inplace=True)

(2): Linear(in_features=400, out_features=200, bias=True)

(3): ReLU(inplace=True)

(4): Linear(in_features=200, out_features=100, bias=True)

(5): ReLU(inplace=True)

(6): Linear(in_features=100, out_features=10, bias=True)

)

criterion = nn.CrossEntropyLoss() # 多クラス分類

optimizer = optim.Adam(model.parameters(), lr=0.001) # オプティマイザー

"""

バッチ学習：全データを一気に学習する

ミニバッチ学習：全データから無作為に抽出して、複数回に分けて学習する

"""

num_epochs = 10 # 何回繰り返すか

losses = [] #損失

accs = [] #精度

for epoch in range(num_epochs):

running_loss = 0.0 # 損失の初期化

running_acc = 0.0 # 精度の初期化

for imgs, labels in train_dataloader:

imgs = imgs.view(num_batches, -1) # １次元ベクトルへ変換

imgs = imgs.to(device) # GPU上へ送る

labels =labels.to(device) # GPU上へ送る

optimizer.zero_grad() # 勾配の初期化

output = model(imgs) # モデル順伝播計算

loss = criterion(output, labels)

running_loss += loss.item()

pred = torch.argmax(output, dim=1) # dim=0はバッチ方向　dim=1 は分類方向

running_acc += torch.mean(pred.eq(labels).float())

loss.backward() # 誤差　逆伝搬計算

optimizer.step() # オプティマイザによるパラメータ更新

running_loss /= len(train_dataloader)

running_acc /= len(train_dataloader)

losses.append(running_loss)

accs.append(running_acc)

print(f'epoch : {epoch}, loss {running_loss}: ,acc : {running_acc}')

# 学習済みパラメーターを抜き出す
params = model.state_dict()

# パラメータをファイルに保存する
torch.save(params, 'model.prm')
# パラメータをファイルから読み込む
param_load = torch.load('model.prm')
param_load
OrderedDict([('classifier.0.weight',
              tensor([[-3.5617e-02,  8.9706e-03,  3.4050e-02,  ..., -9.2121e-03,
                       -6.5885e-05, -1.0760e-02],
                      [ 2.0486e-02, -3.1989e-02,  4.9619e-04,  ..., -1.1030e-02,
                        3.4729e-02, -2.9047e-02],
                      [-5.6085e-03, -2.2364e-02,  4.2380e-03,  ..., -5.4451e-03,
                        3.1651e-02,  3.1243e-02],
                      ...,
                      [ 3.4697e-02, -1.2696e-02, -1.9370e-02,  ..., -1.3790e-02,
                       -2.0770e-02, -2.9269e-02],
                      [-2.5984e-02, -6.8645e-03, -3.7604e-03,  ..., -1.8618e-02,
                       -2.4756e-02,  1.7510e-02],
                      [-1.2803e-02,  3.7466e-03, -2.7087e-02,  ..., -1.4499e-02,
                       -1.8533e-02,  1.8600e-02]], device='cuda:0')),
             ('classifier.0.bias',
              tensor([ 2.5952e-02, -1.7248e-02, -4.3149e-02, -1.6513e-02,  1.0530e-02,
                      -1.2782e-02, -1.2642e-02, -3.1505e-02,  2.4053e-02, -2.4963e-02,
                      -7.3092e-03, -4.1888e-02, -5.4823e-03,  1.1824e-02, -6.8225e-02,
                       1.6625e-02, -1.6976e-02, -1.2219e-02,  1.3059e-02,  2.1564e-02,
                      -1.3850e-02, -3.6530e-02, -8.9879e-03, -1.2830e-02, -8.4952e-03,
                       1.0740e-02,  1.5189e-02,  2.5338e-02, -2.3679e-02, -1.6828e-02,

# 学習済みパラメーターを抜き出す

params = model.state_dict()

# パラメータをファイルに保存する

torch.save(params, 'model.prm')

# パラメータをファイルから読み込む

param_load = torch.load('model.prm')

param_load

OrderedDict([('classifier.0.weight',

tensor([[-3.5617e-02, 8.9706e-03, 3.4050e-02, ..., -9.2121e-03,

-6.5885e-05, -1.0760e-02],

[ 2.0486e-02, -3.1989e-02, 4.9619e-04, ..., -1.1030e-02,

3.4729e-02, -2.9047e-02],

[-5.6085e-03, -2.2364e-02, 4.2380e-03, ..., -5.4451e-03,

3.1651e-02, 3.1243e-02],

...,

[ 3.4697e-02, -1.2696e-02, -1.9370e-02, ..., -1.3790e-02,

-2.0770e-02, -2.9269e-02],

[-2.5984e-02, -6.8645e-03, -3.7604e-03, ..., -1.8618e-02,

-2.4756e-02, 1.7510e-02],

[-1.2803e-02, 3.7466e-03, -2.7087e-02, ..., -1.4499e-02,

-1.8533e-02, 1.8600e-02]], device='cuda:0')),

('classifier.0.bias',

tensor([ 2.5952e-02, -1.7248e-02, -4.3149e-02, -1.6513e-02, 1.0530e-02,

-1.2782e-02, -1.2642e-02, -3.1505e-02, 2.4053e-02, -2.4963e-02,

-7.3092e-03, -4.1888e-02, -5.4823e-03, 1.1824e-02, -6.8225e-02,

1.6625e-02, -1.6976e-02, -1.2219e-02, 1.3059e-02, 2.1564e-02,

-1.3850e-02, -3.6530e-02, -8.9879e-03, -1.2830e-02, -8.4952e-03,

1.0740e-02, 1.5189e-02, 2.5338e-02, -2.3679e-02, -1.6828e-02,

# 学習済みパラメーターを抜き出す
params = model.state_dict()

# パラメータをファイルに保存する
torch.save(params, 'model.prm')

# 学習済みパラメーターを抜き出す

params = model.state_dict()

# パラメータをファイルに保存する

torch.save(params, 'model.prm')

#読み込んだパラメータがちゃんと型にあっているかどうか
model.load_state_dict(param_load)

線形回帰です。

下準備

!python.exe -m pip install --upgrade pip
!pip install --upgrade matplotlib
!pip install --upgrade numpy
!pip install --upgrade pandas
!pip install --upgrade matplotlib

!python.exe -m pip install --upgrade pip

!pip install --upgrade matplotlib

!pip install --upgrade numpy

!pip install --upgrade pandas

!pip install --upgrade matplotlib

モジュール

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
plt.style.use('ggplot')

import torch

import torch.nn as nn

import torch.optim as optim

import matplotlib.pyplot as plt

import numpy as np

%matplotlib inline

plt.style.use('ggplot')

線形にノイズを乗せたサンプルデータを作成する。

# サンプルデータの生成
torch.manual_seed(0)
a = 3
b = 5
x = torch.linspace(0, 10, 101)# 0 から10まで101データ作成する 
x = x.view(101, 1) # 101行 x 1列に変形する　pytroch:batchの次元が頭にくる。そのあとに値
epsilon = torch.randn(101,1) # 101行 x 1列 ノイズデータとして　pytroch:batchの次元が頭にくる。そのあとに値
y = a * x + b + epsilon
plt.scatter(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.show()

# サンプルデータの生成

torch.manual_seed(0)

a = 3

b = 5

x = torch.linspace(0, 10, 101)# 0 から10まで101データ作成する

x = x.view(101, 1) # 101行 x 1列に変形する　pytroch:batchの次元が頭にくる。そのあとに値

epsilon = torch.randn(101,1) # 101行 x 1列ノイズデータとして　pytroch:batchの次元が頭にくる。そのあとに値

y = a * x + b + epsilon

plt.scatter(x, y)

plt.xlabel('x')

plt.ylabel('y')

plt.show()

適当な一次関数を乗せる

class LinearRegression(nn.Module): # 継承 def __init__(self):
        super().__init__() # まず親クラスの初期化（継承しているため）
        self.linear = nn.Linear(in_features=1, out_features=1)#入力xひとつ　出力yひとつ
        
    def forward(self, x):
        output = self.linear(x)
        return output
```


```python
# 訓練前の出力を確認する

plt.scatter(x.detach().numpy(), y,label='y_data')
plt.xlabel('x')
plt.ylabel('y')

model = LinearRegression()
y_before_trainning = model.forward(x)

plt.plot(x.detach().numpy(), y_before_trainning.detach().numpy(), label='y_before_trainning')# detach()が必要

plt.xlabel('x')
plt.ylabel('y')

plt.legend()
plt.show()

class LinearRegression(nn.Module): # 継承 def __init__(self):

super().__init__() # まず親クラスの初期化（継承しているため）

self.linear = nn.Linear(in_features=1, out_features=1)#入力xひとつ　出力yひとつ

def forward(self, x):

output = self.linear(x)

return output

```

```python

# 訓練前の出力を確認する

plt.scatter(x.detach().numpy(), y,label='y_data')

plt.xlabel('x')

plt.ylabel('y')

model = LinearRegression()

y_before_trainning = model.forward(x)

plt.plot(x.detach().numpy(), y_before_trainning.detach().numpy(), label='y_before_trainning')# detach()が必要

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.show()

あってないので学習していく

# 学習していく
criterion = nn.MSELoss() # 損失関数を定義
optimizer = optim.Adam(model.parameters(), lr=0.001) # オプティマイザーを定義 学習率を定義
```


```python
losses = []
num_epoch = 10000
for epoch in range(num_epoch):
    # バッチ学習とする
    
    optimizer.zero_grad() # オプティマイザーの初期化
    y_pred = model(x) # xをネットワークへ入力してyを予測する
    loss = criterion(y_pred, y) # 予測したyと 正解データyとの損失関数を求める
    loss.backward() # 損失関数lossの勾配を求める
    optimizer.step() # オプティマイザーを使って重みパラメータを更新する
    
    # epoch 10 毎に損失を出力する
    if epoch % 10 == 0:
        print(f'epoch : {epoch} , loss : {loss}')
        
    losses.append(loss.detach().numpy()) # 損失の履歴をリストに保存する
```

    epoch : 0 , loss : 102.21257019042969
    epoch : 10 , loss : 101.25241088867188
    epoch : 20 , loss : 100.2987289428711
    epoch : 30 , loss : 99.35151672363281

    epoch : 9960 , loss : 0.9862185120582581
    epoch : 9970 , loss : 0.9861779808998108
    epoch : 9980 , loss : 0.9861387610435486
    epoch : 9990 , loss : 0.9861003160476685

plt.plot(losses)

# 学習していく

criterion = nn.MSELoss() # 損失関数を定義

optimizer = optim.Adam(model.parameters(), lr=0.001) # オプティマイザーを定義学習率を定義

```

```python

losses = []

num_epoch = 10000

for epoch in range(num_epoch):

# バッチ学習とする

optimizer.zero_grad() # オプティマイザーの初期化

y_pred = model(x) # xをネットワークへ入力してyを予測する

loss = criterion(y_pred, y) # 予測したyと正解データyとの損失関数を求める

loss.backward() # 損失関数lossの勾配を求める

optimizer.step() # オプティマイザーを使って重みパラメータを更新する

# epoch 10 毎に損失を出力する

if epoch % 10 == 0:

print(f'epoch : {epoch} , loss : {loss}')

losses.append(loss.detach().numpy()) # 損失の履歴をリストに保存する

```

epoch : 0 , loss : 102.21257019042969

epoch : 10 , loss : 101.25241088867188

epoch : 20 , loss : 100.2987289428711

epoch : 30 , loss : 99.35151672363281

epoch : 9960 , loss : 0.9862185120582581

epoch : 9970 , loss : 0.9861779808998108

epoch : 9980 , loss : 0.9861387610435486

epoch : 9990 , loss : 0.9861003160476685

plt.plot(losses)

学習結果

plt.scatter(x.detach().numpy(), y,label='y_data')
plt.xlabel('x')
plt.ylabel('y')

plt.plot(x.detach().numpy(), y_before_trainning.detach().numpy(), label='y_before_trainning')# detach()が必要

plt.xlabel('x')
plt.ylabel('y')

plt.plot(x.detach().numpy(), y_pred.detach().numpy(), label='y_pred')# detach()が必要

plt.xlabel('x')
plt.ylabel('y')

plt.legend()
plt.show()
```

plt.scatter(x.detach().numpy(), y,label='y_data')

plt.xlabel('x')

plt.ylabel('y')

plt.plot(x.detach().numpy(), y_before_trainning.detach().numpy(), label='y_before_trainning')# detach()が必要

plt.xlabel('x')

plt.ylabel('y')

plt.plot(x.detach().numpy(), y_pred.detach().numpy(), label='y_pred')# detach()が必要

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.show()

```

以上

日: 2023年2月16日

pytorch_mlp

pytorch_linear_regression

2023年2月
月	火	水	木	金	土	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28