dezeroでニューラルネットワークを使った回帰をやってみる

やってみよう。

まずは線形回帰

グラフはこんな感じで線形近似できている。

# 線形回帰
%matplotlib inline
import numpy as np
import matplotlib.pylab as plt
import dezero.functions as F
from dezero import Variable

np.random.seed(0)
x = np.random.rand(100,1)
y = 5 + 2 *x +np.random.rand(100,1)
plt.plot(x,y,'o')

x, y = Variable(x), Variable(y)

# パラメータはW一つ　b一つあればいい
W = Variable(np.zeros((1,1)))
b = Variable(np.zeros((1)))       

def predict(x):
    y = F.matmul(x, W) + b
    return y

def mean_squared_error(x0, x1):
    diff = x0 - x1
    return F.sum(diff ** 2) / len(diff)

lr = 0.1
iters = 100

for i in range(iters):
    # 予測
    y_pred = predict(x)
    
    # 損失
    loss = mean_squared_error(y, y_pred)
    
    # 勾配初期化
    W.cleargrad()
    b.cleargrad()
    
    # 損失勾配
    loss.backward()
    
    # 勾配降下法によるパラメータ更新
    W.data -= lr * W.grad.data
    b.data -= lr *  b.grad.data
    
    if (i % 10) == 0: # 10計算毎に出力をする
        print(i, loss.data)

# 結果表示
print(W.data, b.data)
plt.plot(x.data, W.data * x.data + b.data)

# 線形回帰

%matplotlib inline

import numpy as np

import matplotlib.pylab as plt

import dezero.functions as F

from dezero import Variable

np.random.seed(0)

x = np.random.rand(100,1)

y = 5 + 2 *x +np.random.rand(100,1)

plt.plot(x,y,'o')

x, y = Variable(x), Variable(y)

# パラメータはW一つ　b一つあればいい

W = Variable(np.zeros((1,1)))

b = Variable(np.zeros((1)))

def predict(x):

y = F.matmul(x, W) + b

return y

def mean_squared_error(x0, x1):

diff = x0 - x1

return F.sum(diff ** 2) / len(diff)

lr = 0.1

iters = 100

for i in range(iters):

# 予測

y_pred = predict(x)

# 損失

loss = mean_squared_error(y, y_pred)

# 勾配初期化

W.cleargrad()

b.cleargrad()

# 損失勾配

loss.backward()

# 勾配降下法によるパラメータ更新

W.data -= lr * W.grad.data

b.data -= lr * b.grad.data

if (i % 10) == 0: # 10計算毎に出力をする

print(i, loss.data)

# 結果表示

print(W.data, b.data)

plt.plot(x.data, W.data * x.data + b.data)

損失が徐々に減っていく。いい感じだ。

0 42.296340129442335
10 0.24915731977561134
20 0.10078974954301652
30 0.09461859803040694
40 0.0902667138137311
50 0.08694585483964615
60 0.08441084206493275
70 0.08247571022229121
80 0.08099850454041051
90 0.07987086218625004
[[2.11807369]] [5.46608905]

0 42.296340129442335

10 0.24915731977561134

20 0.10078974954301652

30 0.09461859803040694

40 0.0902667138137311

50 0.08694585483964615

60 0.08441084206493275

70 0.08247571022229121

80 0.08099850454041051

90 0.07987086218625004

[[2.11807369]] [5.46608905]

これをsinカーブでやってみると、直線しか表現できないのでぜんぜんだめ

そこでニューラルネットワークの出番。

活性化関数のお陰で表現が増える

sinカーブにノイズをのせたサンプルデータを作ってニューラルネットワークでやってみよう

損失の減り方をみると開始直後に急激に減って、なんと１万回くらいのところで再度損失が急激に減少した。理由は分からないが　なんかすごい。

ではコードはこちら

# ニューラルネットワークで回帰（成功例）
import numpy as np
import dezero.layers as L

# データサンプルを生成
np.random.seed(0)
x = np.random.rand(100, 1) # 行x列
y = np.sin(2*np.pi*x)+np.random.rand(100,1)
plt.plot(x,y,'o')

# dezero変数へ変換
x, y = Variable(x), Variable(y)

# NNのパラメータの初期化
I, H, O = 1, 10, 1
W1 = Variable(0.01 * np.random.randn(I, H))
b1 = Variable(np.zeros(H))
W2 = Variable(0.01 * np.random.rand(H, O))
b2 = Variable(np.zeros(O))
 
# 推論：ニューラルネットワーク
def predict(x):
    y = F.linear(x, W1, b1)
    y = F.sigmoid(y)
    y = F.linear(y, W2, b2)
    return y

# 損失関数 
def mean_squared_error(x0, x1):
    diff = x0 - x1
    return F.sum(diff ** 2) / len(diff)

# 学習
lr = 0.1
iters = 100000
loss_list = []
iters_list = []

for i in range(iters):
    # 予測
    y_pred = predict(x)
    
    # 損失
    loss = mean_squared_error(y, y_pred)
    
    # 勾配初期化
    W1.cleargrad()
    b1.cleargrad()
    W2.cleargrad()
    b2.cleargrad()
    
    # 損失勾配
    loss.backward()
    
    # 勾配降下法によるパラメータ更新
    W1.data -= lr * W1.grad.data
    b1.data -= lr * b1.grad.data
    W2.data -= lr * W2.grad.data
    b2.data -= lr * b2.grad.data
    
    if (i % 1000) == 0: # 10計算毎に出力をする
        loss_list.append(loss.data) 
        iters_list.append(i)
        print(i, loss.data)
        
# 結果表示
plt.plot(x.data, predict(x).data, 'o') 
plt.show()
plt.plot(iters_list, loss_list)

# ニューラルネットワークで回帰（成功例）

import numpy as np

import dezero.layers as L

# データサンプルを生成

np.random.seed(0)

x = np.random.rand(100, 1) # 行x列

y = np.sin(2*np.pi*x)+np.random.rand(100,1)

plt.plot(x,y,'o')

# dezero変数へ変換

x, y = Variable(x), Variable(y)

# NNのパラメータの初期化

I, H, O = 1, 10, 1

W1 = Variable(0.01 * np.random.randn(I, H))

b1 = Variable(np.zeros(H))

W2 = Variable(0.01 * np.random.rand(H, O))

b2 = Variable(np.zeros(O))

# 推論：ニューラルネットワーク

def predict(x):

y = F.linear(x, W1, b1)

y = F.sigmoid(y)

y = F.linear(y, W2, b2)

return y

# 損失関数

def mean_squared_error(x0, x1):

diff = x0 - x1

return F.sum(diff ** 2) / len(diff)

# 学習

lr = 0.1

iters = 100000

loss_list = []

iters_list = []

for i in range(iters):

# 予測

y_pred = predict(x)

# 損失

loss = mean_squared_error(y, y_pred)

# 勾配初期化

W1.cleargrad()

b1.cleargrad()

W2.cleargrad()

b2.cleargrad()

# 損失勾配

loss.backward()

# 勾配降下法によるパラメータ更新

W1.data -= lr * W1.grad.data

b1.data -= lr * b1.grad.data

W2.data -= lr * W2.grad.data

b2.data -= lr * b2.grad.data

if (i % 1000) == 0: # 10計算毎に出力をする

loss_list.append(loss.data)

iters_list.append(i)

print(i, loss.data)

# 結果表示

plt.plot(x.data, predict(x).data, 'o')

plt.show()

plt.plot(iters_list, loss_list)

次回予告

次はdezeroをフル活用でやってみよう

オプティマイザとかも予め用意されているらしい。

グラフ　第２軸の作り方

matplotlibを使って２軸あるグラフを作成してみます。

import numpy as np
import matplotlib.pyplot as ple
%matplotlib inline

# サンプルデータ生成
np.random.seed(0)
time = np.arange(0,11)
values = np.random.randn(11).cumsum()
values2 = np.random.randn(11).cumsum() * 2

#枠を確保
fig = plt.figure(figsize=(10, 5))

# サブプロットを使用する
ax1 = fig.add_subplot(1,1,1)
ax1.scatter(time, values, label='test data')
ax1.plot(time, values, label='simulation')
ax1.set_xlabel('Time t / s')
ax1.set_ylabel('Value')
ax1.legend(loc='best')

# ここまでは同じ

# 第２軸を設定する
ax2 = ax1.twinx() #Timeを共通として第２軸を定義する　ツインメソド
ax2.scatter(time, values2, label='test data 2', color='blue', marker='x', )
ax2.plot(time, values2, label='simulation 2', color='blue')

# この時点ではグリッドが２軸分重なってしまっているので修正が必要
ax1.set_ylim([0, 10])
ax2.set_ylim([0, 10])
ax2.grid(False)

# 凡例がまだかぶっている
ax1.legend(bbox_to_anchor=(1.38, 0.8))
ax2.legend(bbox_to_anchor=(1.40, 0.5))

# グラフを保存する
plt.tight_layout()
plt.savefig('data/fig_001.png', dpi=300)

import numpy as np

import matplotlib.pyplot as ple

%matplotlib inline

# サンプルデータ生成

np.random.seed(0)

time = np.arange(0,11)

values = np.random.randn(11).cumsum()

values2 = np.random.randn(11).cumsum() * 2

#枠を確保

fig = plt.figure(figsize=(10, 5))

# サブプロットを使用する

ax1 = fig.add_subplot(1,1,1)

ax1.scatter(time, values, label='test data')

ax1.plot(time, values, label='simulation')

ax1.set_xlabel('Time t / s')

ax1.set_ylabel('Value')

ax1.legend(loc='best')

# ここまでは同じ

# 第２軸を設定する

ax2 = ax1.twinx() #Timeを共通として第２軸を定義する　ツインメソド

ax2.scatter(time, values2, label='test data 2', color='blue', marker='x', )

ax2.plot(time, values2, label='simulation 2', color='blue')

# この時点ではグリッドが２軸分重なってしまっているので修正が必要

ax1.set_ylim([0, 10])

ax2.set_ylim([0, 10])

ax2.grid(False)

# 凡例がまだかぶっている

ax1.legend(bbox_to_anchor=(1.38, 0.8))

ax2.legend(bbox_to_anchor=(1.40, 0.5))

# グラフを保存する

plt.tight_layout()

plt.savefig('data/fig_001.png', dpi=300)

Python3: 3Dプロット from mpl_toolkits.mplot3d import Axes3D

3Dプロットのやりかたです。

モジュールは

from mpl_toolkits.mplot3d import Axes3D
%matplotlib notebook

を使っていきます。

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib notebook

# サンプルデータ：粒子のブラウン運動を模擬
x = np.random.randn(100).cumsum() #1ステップ毎に移動していく状態を累積cumsumで表現
y = np.random.randn(100).cumsum()
z = np.random.randn(100).cumsum()
value = np.random.randn(100).cumsum()

# ggplotのスタイルを使用する
plt.style.use('ggplot')

# 枠を確保
fig = plt.figure()

# figを 3Dへ 変換
ax = Axes3D(fig)
ax.plot(x, y, z, label='particle moving', color ='black')

# カラーバー
mappable = ax.scatter(x, y, z, c=value, cmap='bwr')
fig.colorbar(mappable, ax=ax)

# タイトル　ラベルを設定
ax.set_title('title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.set_zlabel('zlabel')

# 凡例を設定
ax.legend()

# リミットを設定
ax.set_xlim(-10, +10)
ax.set_ylim(-10, +10)
ax.set_zlim(-10, +10)

# グリッドを表示
ax.grid(True)
plt.show()