デフォルトのコード

import numpy as np

import matplotlib.pyplot as plt

N = 500 # 1クラスあたりのデータ数

D = 2 # データの次元

K = 3 # クラス数
X = np.zeros((N*K,D)) # データ行列 (each row = single example)

y = np.zeros(N*K, dtype='uint8') # ラベル
np.random.seed(0) #シード値固定

#半径、角度を変化させながらデータ行列に代入

for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N) # 半径

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # 角度

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
#3×3の単位行列を生成してラベルのワンホットエンコーディング

n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
# データを描画

plt.scatter(X[:, 0], X[:, 1], c=Y, s=40, cmap=plt.cm.Spectral)

plt.show()

デフォルトのコード

import numpy as np

N = 500

D = 2

K = 3 
X = np.zeros((N*K,D))

y = np.zeros(N*K, dtype='uint8') 
np.random.seed(0) 
for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N)

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
#X、Yの形状

print(X.shape)

print(Y.shape)
#Yの中身を見てみる

print(Y)

デフォルトのコード

import torch

import torch.nn as nn

from torch.nn import functional as F

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from torch.utils.data import TensorDataset

from torch.utils.data import DataLoader

N = 500 # 1クラスあたりのデータ数

D = 2 # データの次元

K = 3 # クラス数
#データ定義

X = np.zeros((N*K,D))

y = np.zeros(N*K, dtype='uint8') 
np.random.seed(0)
for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N)

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
#3×3の単位行列を生成してラベルのワンホットエンコーディング

n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
#データを8:2に分割

train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.2) 
#float32のtensorに変換

train_X = torch.FloatTensor(train_X)

train_Y = torch.FloatTensor(train_Y)

test_X = torch.FloatTensor(test_X)

test_Y = torch.FloatTensor(test_Y)
train = TensorDataset(train_X, train_Y) #train_X、train_Yを一つにまとめる
BATCH_SIZE = 10 #ミニバッチのサイズ
#訓練用データのDataloaderを作成

train_dataloader = DataLoader(

    train,

    batch_size=BATCH_SIZE,

    shuffle=True

)
#モデル定義

class Net(nn.Module):

    def __init__(self):

        super(Net, self).__init__()

        self.fc1 = nn.Linear(2, 8)

        self.fc2 = nn.Linear(8, 3) #pytorchの仕様のため、出力層の活性化関数は省略
    def forward(self, x):

        x = self.fc1(x)

        x = F.relu(x)

        x = self.fc2(x)

        return x    
# インスタンス化

net = Net()
# 損失関数の設定(クロスエントロピー誤差)

criterion = nn.CrossEntropyLoss() #この中でソフトマックス関数と同じ処理をしている
# 最適化手法の選択(SGD)

optimizer = torch.optim.SGD(net.parameters(), lr=0.1)
y_axis_list = []#損失プロット用y軸方向リスト
#訓練ループ

for epoch in range(200):

    for batch, label in train_dataloader:

        optimizer.zero_grad()
        t_p = net(batch)
        loss = criterion(t_p,label)
        loss.backward()
        optimizer.step()
    y_axis_list.append(loss.detach().numpy())#y軸方向のリストに損失の値を代入
    if epoch % 10 == 0:#10エポック毎に損失の値を表示

      print("epoch: %d  loss: %f" % (epoch+1 ,float(loss)))
x_axis_list = [num for num in range(200)]#損失プロット用x軸方向リスト
#損失の描画

plt.xlabel("epoch")

plt.ylabel("loss")

plt.plot(x_axis_list,y_axis_list)

plt.show()

デフォルトのコード

import torch

import torch.nn as nn

from torch.nn import functional as F

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from torch.utils.data import TensorDataset

from torch.utils.data import DataLoader

N = 500 # 1クラスあたりのデータ数

D = 2 # データの次元

K = 3 # クラス数
#データ定義

X = np.zeros((N*K,D))

y = np.zeros(N*K, dtype='uint8') 
np.random.seed(0)
for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N)

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
#3×3の単位行列を生成してラベルのワンホットエンコーディング

n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
#データを8:2に分割

train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.2) 
#float32のtensorに変換

train_X = torch.FloatTensor(train_X)

train_Y = torch.FloatTensor(train_Y)

test_X = torch.FloatTensor(test_X)

test_Y = torch.FloatTensor(test_Y)
train = TensorDataset(train_X, train_Y) #train_X、train_Yを一つにまとめる
BATCH_SIZE = 10 #ミニバッチのサイズ
#訓練用データのDataloaderを作成

train_dataloader = DataLoader(

    train,

    batch_size=BATCH_SIZE,

    shuffle=True

)
#モデル定義

class Net(nn.Module):

    def __init__(self):

        super(Net, self).__init__()

        self.fc1 = nn.Linear(2, 8)

        self.fc2 = nn.Linear(8, 3) #pytorchの仕様のため、出力層の活性化関数は省略
    def forward(self, x):

        x = self.fc1(x)

        x = F.relu(x)

        x = self.fc2(x)

        return x    
# インスタンス化

net = Net()
# 損失関数の設定(クロスエントロピー誤差)

criterion = nn.CrossEntropyLoss() #この中でソフトマックス関数と同じ処理をしている
# 最適化手法の選択(SGD)

optimizer = torch.optim.SGD(net.parameters(), lr=0.1)
#訓練ループ

for epoch in range(200):

    for batch, label in train_dataloader:

        optimizer.zero_grad()
        t_p = net(batch)
        loss = criterion(t_p,label)
        loss.backward()
        optimizer.step()
    if epoch % 10 == 0:#10エポック毎に損失の値を表示

      print("epoch: %d  loss: %f" % (epoch+1 ,float(loss)))
with torch.no_grad():# 試験用データでは勾配を計算しない

    pred_labels = [] # 各バッチごとの結果格納用
    for x in test_X:

            pred = net(x) #モデルの出力

            #argmax関数で出力における最大値のインデックスを取得し、ワンホットエンコーディングされたラベルに変換

            if torch.argmax(pred) == torch.tensor(0) :

              pred_labels.append([1.,0.,0.])
            elif torch.argmax(pred) == torch.tensor(1):

              pred_labels.append([0.,1.,0.])
            else:

              pred_labels.append([0.,0.,1.])  
pred_labels = np.array(pred_labels) #numpy arrayに変換
# データを描画

plt.scatter(test_X[:, 0], test_X[:, 1], c=pred_labels, s=40, cmap=plt.cm.Spectral)

plt.show()

デフォルトのコード

import torch

import torch.nn as nn

from torch.nn import functional as F

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from torch.utils.data import TensorDataset

from torch.utils.data import DataLoader

N = 500 # 1クラスあたりのデータ数

D = 2 # データの次元

K = 3 # クラス数
#データ定義

X = np.zeros((N*K,D))

y = np.zeros(N*K, dtype='uint8') 
np.random.seed(0)
for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N)

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
#3×3の単位行列を生成してラベルのワンホットエンコーディング

n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
#データを8:2に分割

train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.2) 
#float32のtensorに変換

train_X = torch.FloatTensor(train_X)

train_Y = torch.FloatTensor(train_Y)

test_X = torch.FloatTensor(test_X)

test_Y = torch.FloatTensor(test_Y)
train = TensorDataset(train_X, train_Y) #train_X、train_Yを一つにまとめる
BATCH_SIZE = 10 #ミニバッチのサイズ
#訓練用データのDataloaderを作成

train_dataloader = DataLoader(

    train,

    batch_size=BATCH_SIZE,

    shuffle=True

)
#モデル定義

class Net_2(nn.Module):

    def __init__(self):

        super(Net_2, self).__init__()

        self.fc1 = nn.Linear(2, 8)

        self.fc2 = nn.Linear(8, 8) #新しく線形変換層を追加

        self.fc3 = nn.Linear(8, 3) 
    # 順伝播

    def forward(self, x):

        x = self.fc1(x)

        x = F.relu(x)

        x = self.fc2(x)

        x = F.relu(x)

        x = self.fc3(x)

        return x    
net2 = Net_2()
criterion_2 = nn.CrossEntropyLoss() 
optimizer_2 = torch.optim.SGD(net2.parameters(), lr=0.1)
y_axis_list = []#損失プロット用y軸方向リスト
#訓練ループ

for epoch in range(100):

    for batch, label in train_dataloader: 
        optimizer_2.zero_grad()
        t_p = net2(batch)
        loss_2 = criterion_2(t_p,label)
        loss_2.backward()
        optimizer_2.step()
    y_axis_list.append(loss_2.detach().numpy())
    if epoch % 10 == 0:#10エポック毎に損失の値を表示

      print("epoch: %d  loss: %f" % (epoch+1 ,float(loss_2)))
x_axis_list = [num for num in range(100)]#損失プロット用x軸方向リスト
#損失の描画

plt.xlabel("epoch")

plt.ylabel("loss")

plt.plot(x_axis_list,y_axis_list)

plt.show()      

デフォルトのコード

import torch

import torch.nn as nn

from torch.nn import functional as F

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from torch.utils.data import TensorDataset

from torch.utils.data import DataLoader

N = 500 # 1クラスあたりのデータ数

D = 2 # データの次元

K = 3 # クラス数
#データ定義

X = np.zeros((N*K,D))

y = np.zeros(N*K, dtype='uint8') 
np.random.seed(0)
for j in range(K):

    ix = range(N*j,N*(j+1))

    r = np.linspace(0.0,1,N)

    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2

    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
    y[ix] = j
#3×3の単位行列を生成してラベルのワンホットエンコーディング

n_values = np.max(y) + 1

Y = np.eye(n_values)[y] 
#データを8:2に分割

train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.2) 
#float32のtensorに変換

train_X = torch.FloatTensor(train_X)

train_Y = torch.FloatTensor(train_Y)

test_X = torch.FloatTensor(test_X)

test_Y = torch.FloatTensor(test_Y)
train = TensorDataset(train_X, train_Y) #train_X、train_Yを一つにまとめる
BATCH_SIZE = 10 #ミニバッチのサイズ
#訓練用データのDataloaderを作成

train_dataloader = DataLoader(

    train,

    batch_size=BATCH_SIZE,

    shuffle=True

)
#モデル定義

class Net_2(nn.Module):

    def __init__(self):

        super(Net_2, self).__init__()

        self.fc1 = nn.Linear(2, 8)

        self.fc2 = nn.Linear(8, 8) #新しく線形変換層を追加

        self.fc3 = nn.Linear(8, 3) 
    # 順伝播

    def forward(self, x):

        x = self.fc1(x)

        x = F.relu(x)

        x = self.fc2(x)

        x = F.relu(x)

        x = self.fc3(x)

        return x    
net2 = Net_2()
criterion_2 = nn.CrossEntropyLoss() 
optimizer_2 = torch.optim.SGD(net2.parameters(), lr=0.1)
#訓練ループ

for epoch in range(100):

    for batch, label in train_dataloader:
        optimizer_2.zero_grad()
        t_p = net2(batch)
        loss_2 = criterion_2(t_p,label)
        loss_2.backward()
        optimizer_2.step()
    if epoch % 10 == 0:#10エポック毎に損失の値を表示

      print("epoch: %d  loss: %f" % (epoch+1 ,float(loss_2)))
with torch.no_grad():# 試験用データでは勾配を計算しない

    pred_labels = [] # 各バッチごとの結果格納用
    for x in test_X:

            pred = net2(x)
            if torch.argmax(pred) == torch.tensor(0) :

              pred_labels.append([1.,0.,0.])
            elif torch.argmax(pred) == torch.tensor(1):

              pred_labels.append([0.,1.,0.])
            else:

              pred_labels.append([0.,0.,1.])  
pred_labels = np.array(pred_labels) 
# データを描画

plt.scatter(test_X[:, 0], test_X[:, 1], c=pred_labels, s=40, cmap=plt.cm.Spectral)

plt.show()