PySimpleGUI のメモ

import PySimpleGUI as sg

size = (5,5)
font = ('miryo', (5,5))
layout = [[sg.Text('計算機')],
            [sg.Checkbox('a',key='a'),sg.Checkbox('b',key='b')],
            [sg.Radio('足し算', group_id='method', key='sum', default=True), sg.Radio('引き算', group_id='method', key='sub')],
            [sg.Text('数値１'), sg.Input(key='value1')],
            [sg.Text('数値２'), sg.Input(key='value2')],
            [sg.Button('計算する', key='culc'), sg.Button(image_filename='pic001.gif', image_size=(100,20))],
            [sg.Text('計算結果'), sg.Input(default_text='結果', key='result')],     
]

window_size = (640,480)
window = sg.Window('タイトル', layout, size = window_size)

while True:
    event, value = window.read()
    if event == None:
        break
    if event == 'culc':
        print(event, value)
        sg.PopupYesNo('計算しますか')

        if value['a'] == True:
            v1 = float(value['value1'])
            v2 = float(value['value2'])
            v3 = v1 + v2
            print(v3)
            window['result'].update(v3)

        sg.Popup('計算完了')

window.close()

import PySimpleGUI as sg

size = (5,5)

font = ('miryo', (5,5))

layout = [[sg.Text('計算機')],

[sg.Checkbox('a',key='a'),sg.Checkbox('b',key='b')],

[sg.Radio('足し算', group_id='method', key='sum', default=True), sg.Radio('引き算', group_id='method', key='sub')],

[sg.Text('数値１'), sg.Input(key='value1')],

[sg.Text('数値２'), sg.Input(key='value2')],

[sg.Button('計算する', key='culc'), sg.Button(image_filename='pic001.gif', image_size=(100,20))],

[sg.Text('計算結果'), sg.Input(default_text='結果', key='result')],

]

window_size = (640,480)

window = sg.Window('タイトル', layout, size = window_size)

while True:

event, value = window.read()

if event == None:

break

if event == 'culc':

print(event, value)

sg.PopupYesNo('計算しますか')

if value['a'] == True:

v1 = float(value['value1'])

v2 = float(value['value2'])

v3 = v1 + v2

print(v3)

window['result'].update(v3)

sg.Popup('計算完了')

window.close()

dezeroでニューラルネットワーク２ model, optimizer, MSEをフル活用

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

dezeroに搭載されている、model, optimizer, MSEをフル活用したバージョンです。

結果は前回と同様によく回帰できていますね。

損失の減り方がとても早いです。今回はAdamを使っているのでうまく昨日しているようです。悩んだらAdamは間違ってないようです。

スクリプトはこちらに貼っておきます。

# ニューラルネットワークで回帰（レイヤ　モデル　最適化手法）
import numpy as np
from dezero import Variable
from dezero import Model
import dezero.layers as L
import dezero.functions as F
from dezero import optimizers

# データサンプルを生成
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')

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

# モデルをdezeroから継承する
class TwoLayerNet(Model):
    def __init__(self, hidden_size, out_size):
        super().__init__()
        self.l1 = L.Linear(hidden_size)
        self.l2 = L.Linear(out_size)
        
    def forward(self, x):
        y = F.sigmoid(self.l1(x))
        y = self.l2(y)
        return y

# モデルのインスタンスを作成
model = TwoLayerNet(10, 1)#隠れ層のサイズ, 出力層のサイズ

# オプティマイザを生成
#optimizer = optimizers.SGD(lr) # 最初にお世話になるSGD
optimizer = optimizers.Adam(lr) # 悩んだらアダム
optimizer.setup(model) # モデルのセットアップする　意味不明。

""" いらないくなった
# 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)
"""

for i in range(iters):
    # 予測
    #y_pred = predict(x)
    y_pred = model.forward(x) # 実はもうある
    
    # 損失
    #loss = mean_squared_error(y, y_pred)
    loss = F.mean_squared_error(y, y_pred) # 実はもうある
    
    """いらなくなった
    # 勾配初期化
    W1.cleargrad()
    b1.cleargrad()
    W2.cleargrad()
    b2.cleargrad()
    """
    # 勾配初期化
    model.cleargrads() # 代わりにこれでいい
    
    # 損失勾配
    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
    """
    """modelは使うが optimizerを使わないときはこのスクリプトを使う
    # パラメータ更新
    for p in model.params(): # モデルパラムスに保存されてるっぽい
        p.data -= lr * p.grad.data # 勾配降下法
    """
    # オプティマイザを使って　パラメータ更新
    optimizer.update()
    
    if (i % 1000) == 0: # たまに損失の計算状況を出力をする
        print(i, loss.data)
        loss_list.append(loss.data) 
        iters_list.append(i)
        
# 結果表示
plt.plot(x.data, predict(x).data, 'o') 
plt.show()
plt.plot(iters_list, loss_list)

100

101

102

103

104

105

106

107

108

109

110

# ニューラルネットワークで回帰（レイヤ　モデル　最適化手法）

import numpy as np

from dezero import Variable

from dezero import Model

import dezero.layers as L

import dezero.functions as F

from dezero import optimizers

# データサンプルを生成

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

# 学習

lr = 0.1

iters = 100000

loss_list = []

iters_list = []

# モデルをdezeroから継承する

class TwoLayerNet(Model):

def __init__(self, hidden_size, out_size):

super().__init__()

self.l1 = L.Linear(hidden_size)

self.l2 = L.Linear(out_size)

def forward(self, x):

y = F.sigmoid(self.l1(x))

y = self.l2(y)

return y

# モデルのインスタンスを作成

model = TwoLayerNet(10, 1)#隠れ層のサイズ, 出力層のサイズ

# オプティマイザを生成

#optimizer = optimizers.SGD(lr) # 最初にお世話になるSGD

optimizer = optimizers.Adam(lr) # 悩んだらアダム

optimizer.setup(model) # モデルのセットアップする　意味不明。

""" いらないくなった

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

"""

for i in range(iters):

# 予測

#y_pred = predict(x)

y_pred = model.forward(x) # 実はもうある

# 損失

#loss = mean_squared_error(y, y_pred)

loss = F.mean_squared_error(y, y_pred) # 実はもうある

"""いらなくなった

# 勾配初期化

W1.cleargrad()

b1.cleargrad()

W2.cleargrad()

b2.cleargrad()

"""

# 勾配初期化

model.cleargrads() # 代わりにこれでいい

# 損失勾配

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

"""

"""modelは使うが optimizerを使わないときはこのスクリプトを使う

# パラメータ更新

for p in model.params(): # モデルパラムスに保存されてるっぽい

p.data -= lr * p.grad.data # 勾配降下法

"""

# オプティマイザを使って　パラメータ更新

optimizer.update()

if (i % 1000) == 0: # たまに損失の計算状況を出力をする

print(i, loss.data)

loss_list.append(loss.data)

iters_list.append(i)

# 結果表示

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

plt.show()

plt.plot(iters_list, loss_list)

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をフル活用でやってみよう

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

Dog_to_Headのpythonバージョン　AndroidスマホのPyroid3

以前Kotlinで作ったDog_to_Headのpythonバージョンです。

AndroidスマホのPyroid3で動かすために作りました。GUIつくるのめんどくさかったのでCUIのまま使ってください。

def dog_to_head(heads ,dogs , current_dog ,target_dog):
    # ヘッド更新回数：初期化
    rounds = 0

    while True:

        # 現在ドッグ番号が目標ドッグ番号よりも大きい場合は　ヘッドを回転させても現在ドッグ番号が増えて離れていってしまうだけ。
        # 対策：現在ドッグ番号が、ドッグ数を超えた場合、
        #現在ドッグ番号からドッグ数を引き算して、ドッグ数を超えないように都度修正する。
        if current_dog > dogs:
            current_dog -= dogs

        # ヘッド更新回数増加により更新された現在ドッグ番号が一致したとき、ループから抜ける
        if current_dog == target_dog:
            break

        # ヘッド更新回数をカウントアップ
        rounds += 1

        # ヘッド回数更新による現在ドッグ番号の更新
        current_dog += heads

        print(rounds, current_dog, target_dog)

    # 結果を出力する
    print(f"ヘッドをあと {rounds} 回転 させる必要があります。")  
    
if __name__ == '__main__':

    """
    heads = 12 # ヘッド数
    dogs = 223 # ドッグ数
    current_dog = 18 # 現在のドッグ番号
    target_dog = 17 # ヘッド更新後、目標とするドッグ番号
    """
    heads = int(input('ヘッド数 12: '))
    dogs = int(input('ドッグ数 223: '))
    target_dog = int(input('ヘッド更新後、目標とするドッグ番号 17: '))
    current_dog = int(input('現在のドッグ番号 : '))

    dog_to_head(heads, dogs, current_dog, target_dog)

def dog_to_head(heads ,dogs , current_dog ,target_dog):

# ヘッド更新回数：初期化

rounds = 0

while True:

# 現在ドッグ番号が目標ドッグ番号よりも大きい場合は　ヘッドを回転させても現在ドッグ番号が増えて離れていってしまうだけ。

# 対策：現在ドッグ番号が、ドッグ数を超えた場合、

#現在ドッグ番号からドッグ数を引き算して、ドッグ数を超えないように都度修正する。

if current_dog > dogs:

current_dog -= dogs

# ヘッド更新回数増加により更新された現在ドッグ番号が一致したとき、ループから抜ける

if current_dog == target_dog:

break

# ヘッド更新回数をカウントアップ

rounds += 1

# ヘッド回数更新による現在ドッグ番号の更新

current_dog += heads

print(rounds, current_dog, target_dog)

# 結果を出力する

print(f"ヘッドをあと {rounds} 回転させる必要があります。")

if __name__ == '__main__':

"""

heads = 12 # ヘッド数

dogs = 223 # ドッグ数

current_dog = 18 # 現在のドッグ番号

target_dog = 17 # ヘッド更新後、目標とするドッグ番号

"""

heads = int(input('ヘッド数 12: '))

dogs = int(input('ドッグ数 223: '))

target_dog = int(input('ヘッド更新後、目標とするドッグ番号 17: '))

current_dog = int(input('現在のドッグ番号 : '))

dog_to_head(heads, dogs, current_dog, target_dog)

強化学習：多腕バンディット問題　定常・非定常

強化学習の基礎、多腕バンディット問題

面白そうなのでやってみました。

ちなみに、本日のアイキャッチは画像生成AIであるStableDiffusionで「multi arms bandit problem by stable diffusion」というワードから生成した一枚です。

モジュールインポート　クラス作成

# 強化学習　バンディット問題
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

class Bandit():
    def __init__(self, arms=10):
        self.arms = arms
        self.rates = np.random.rand(self.arms)# 勝率
    
    def play(self, arm): # プレイして報酬を得る
        if self.rates[arm] > np.random.rand():
            return 1 # 勝利したときの報酬
        else:
            return 0 # 敗北したときの報酬
        
class NonStatBandit():
    def __init__(self, arms=10):
        self.arms = arms
        self.rates = np.random.rand(self.arms)# 勝率
    
    def play(self, arm): # プレイして報酬を得る
        self.rates += 0.01 * np.random.randn(self.arms) # 報酬にノイズを導入する
        
        if self.rates[arm] > np.random.rand():
            return 1 # 勝利したときの報酬
        else:
            return 0 # 敗北したときの報酬
        
        
class AlphaAgent:
    def __init__(self, epsilon, alpha, actions=10):
        self.epsilon = epsilon
        self.Qs = np.zeros(actions)
        self.alpha = alpha
    
    def get_action(self): 
        # ランダム　または　最大価値　の行動を選択
        if np.random.rand() < self.epsilon: # 貪欲を選択した場合
            return np.random.randint(0, len(self.Qs)) # ランダムに行動を選択する
        else:
            return np.argmax(self.Qs)
        
    def update(self, action, reward):
        # alphaで価値を更新する
        self.Qs[action] += self.alpha * (reward - self.Qs[action])

# 強化学習　バンディット問題

%matplotlib inline

import numpy as np

import matplotlib.pyplot as plt

class Bandit():

def __init__(self, arms=10):

self.arms = arms

self.rates = np.random.rand(self.arms)# 勝率

def play(self, arm): # プレイして報酬を得る

if self.rates[arm] > np.random.rand():

return 1 # 勝利したときの報酬

else:

return 0 # 敗北したときの報酬

class NonStatBandit():

def __init__(self, arms=10):

self.arms = arms

self.rates = np.random.rand(self.arms)# 勝率

def play(self, arm): # プレイして報酬を得る

self.rates += 0.01 * np.random.randn(self.arms) # 報酬にノイズを導入する

if self.rates[arm] > np.random.rand():

return 1 # 勝利したときの報酬

else:

return 0 # 敗北したときの報酬

class AlphaAgent:

def __init__(self, epsilon, alpha, actions=10):

self.epsilon = epsilon

self.Qs = np.zeros(actions)

self.alpha = alpha

def get_action(self):

# ランダム　または　最大価値　の行動を選択

if np.random.rand() < self.epsilon: # 貪欲を選択した場合

return np.random.randint(0, len(self.Qs)) # ランダムに行動を選択する

else:

return np.argmax(self.Qs)

def update(self, action, reward):

# alphaで価値を更新する

self.Qs[action] += self.alpha * (reward - self.Qs[action])

バンディットとエージェントで学習　定常問題

# 定常バンディット問題を解いてみる
np.random.seed(0)
bandit = Bandit(arms=10)

agent = AlphaAgent(epsilon=0.1, alpha=0.8, actions=10)
steps = 1_000

total_reward = 0
total_rewards = []
rates =[]

for step in range(steps):
    action = agent.get_action() #　行動を選択
    reward = bandit.play(action)# 行動し報酬を得る
    agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。
    
    total_reward += reward
    total_rewards.append(total_reward) 
    rates.append(total_reward / (step + 1))
    
plt.bar(np.arange(0,10,1),bandit.rates, color='red', width=0.3, label='rates', align="center")
plt.bar(np.arange(0,10,1) + 0.3, agent.Qs, color='blue', width=0.3, label='Qs', align="center")
plt.xticks(np.arange(0,10,1))
plt.xticks(np.arange(0,10,1))
plt.legend()
plt.show()

print('total_reward : ', total_reward)
plt.plot(total_rewards, label='total_reward')
plt.legend()
plt.show()

print('final_rate : ', rates[-1])
plt.plot(rates, label='rates')
plt.legend()
plt.show()

# 定常バンディット問題を解いてみる

np.random.seed(0)

bandit = Bandit(arms=10)

agent = AlphaAgent(epsilon=0.1, alpha=0.8, actions=10)

steps = 1_000

total_reward = 0

total_rewards = []

rates =[]

for step in range(steps):

action = agent.get_action() #　行動を選択

reward = bandit.play(action)# 行動し報酬を得る

agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

total_reward += reward

total_rewards.append(total_reward)

rates.append(total_reward / (step + 1))

plt.bar(np.arange(0,10,1),bandit.rates, color='red', width=0.3, label='rates', align="center")

plt.bar(np.arange(0,10,1) + 0.3, agent.Qs, color='blue', width=0.3, label='Qs', align="center")

plt.xticks(np.arange(0,10,1))

plt.legend()

plt.show()

print('total_reward : ', total_reward)

plt.plot(total_rewards, label='total_reward')

plt.legend()

plt.show()

print('final_rate : ', rates[-1])

plt.plot(rates, label='rates')

plt.legend()

plt.show()

結果

モデルを２００回繰り返した平均結果

# 定常バンディット問題をruns = 200回ランダムに解いて平均を見る
#np.random.seed(0)
runs = 200    # モデル数
steps = 1_000 # 学習の更新ステップ数

actions = 10  # 選択可能な「行動」の数
epsilon = 0.1 # 貪欲率
alpha = 0.8   # 学習率

# 勝率の結果を保存するテーブルを生成する
all_rates = np.zeros((runs, steps)) # 試行NO. x １試行の中での強化ステップNO. ※引数はタプル型


for run in range(runs): 
    # バンディットとエージェントのインスタンスを生成する
    bandit = Bandit(arms=actions)
    agent = AlphaAgent(epsilon=epsilon, alpha=alpha, actions=actions)
    
    # 報酬の初期化
    total_reward = 0
    total_rewards = []
    rates = []
    
    for step in range(steps):
        action = agent.get_action() #　行動を選択
        reward = bandit.play(action)# 行動し報酬を得る
        agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

        total_reward += reward
        total_rewards.append(total_reward) 
        rates.append(total_reward / (step + 1))
    
    all_rates[run] = rates # 勝率の結果を保存する

# 定常バンディット問題をruns = 200回ランダムに解いて平均を見る

#np.random.seed(0)

runs = 200 # モデル数

steps = 1_000 # 学習の更新ステップ数

actions = 10 # 選択可能な「行動」の数

epsilon = 0.1 # 貪欲率

alpha = 0.8 # 学習率

# 勝率の結果を保存するテーブルを生成する

all_rates = np.zeros((runs, steps)) # 試行NO. x １試行の中での強化ステップNO. ※引数はタプル型

for run in range(runs):

# バンディットとエージェントのインスタンスを生成する

bandit = Bandit(arms=actions)

agent = AlphaAgent(epsilon=epsilon, alpha=alpha, actions=actions)

# 報酬の初期化

total_reward = 0

total_rewards = []

rates = []

for step in range(steps):

action = agent.get_action() #　行動を選択

reward = bandit.play(action)# 行動し報酬を得る

agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

total_reward += reward

total_rewards.append(total_reward)

rates.append(total_reward / (step + 1))

all_rates[run] = rates # 勝率の結果を保存する

# 200モデル分
for run in range(runs):
    plt.plot(all_rates[run])
plt.show()

# 200モデル分の平均
average_rates = all_rates.mean(axis=0)
plt.plot(average_rates)
plt.show()

# 200モデル分

for run in range(runs):

plt.plot(all_rates[run])

plt.show()

# 200モデル分の平均

average_rates = all_rates.mean(axis=0)

plt.plot(average_rates)

plt.show()

バンディットとエージェントで学習　非定常問題

# 非定常バンディット問題を解いてみる
np.random.seed(0)
bandit = NonStatBandit(arms=10)

agent = AlphaAgent(epsilon=0.1, alpha=0.8, actions=10)
steps = 1_000

total_reward = 0
total_rewards = []
rates =[]

for step in range(steps):
    action = agent.get_action() #　行動を選択
    reward = bandit.play(action)# 行動し報酬を得る
    agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。
    
    total_reward += reward
    total_rewards.append(total_reward) 
    rates.append(total_reward / (step + 1))
    
plt.bar(np.arange(0,10,1),bandit.rates, color='red', width=0.3, label='rates', align="center")
plt.bar(np.arange(0,10,1) + 0.3, agent.Qs, color='blue', width=0.3, label='Qs', align="center")
plt.xticks(np.arange(0,10,1))
plt.xticks(np.arange(0,10,1))
plt.legend()
plt.show()

print('total_reward : ', total_reward)
plt.plot(total_rewards, label='total_reward')
plt.legend()
plt.show()

print('final_rate : ', rates[-1])
plt.plot(rates, label='rates')
plt.legend()
plt.show()

# 非定常バンディット問題を解いてみる

np.random.seed(0)

bandit = NonStatBandit(arms=10)

agent = AlphaAgent(epsilon=0.1, alpha=0.8, actions=10)

steps = 1_000

total_reward = 0

total_rewards = []

rates =[]

for step in range(steps):

action = agent.get_action() #　行動を選択

reward = bandit.play(action)# 行動し報酬を得る

agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

total_reward += reward

total_rewards.append(total_reward)

rates.append(total_reward / (step + 1))

plt.bar(np.arange(0,10,1),bandit.rates, color='red', width=0.3, label='rates', align="center")

plt.bar(np.arange(0,10,1) + 0.3, agent.Qs, color='blue', width=0.3, label='Qs', align="center")

plt.xticks(np.arange(0,10,1))

plt.legend()

plt.show()

print('total_reward : ', total_reward)

plt.plot(total_rewards, label='total_reward')

plt.legend()

plt.show()

print('final_rate : ', rates[-1])

plt.plot(rates, label='rates')

plt.legend()

plt.show()

結果

モデルを２００回繰り返した平均結果

# 非定常バンディット問題をruns = 200回ランダムに解いて平均を見る
#np.random.seed(0)
runs = 200    # モデル数
steps = 1_000 # 学習の更新ステップ数

actions = 10  # 選択可能な「行動」の数
epsilon = 0.1 # 貪欲率
alpha = 0.8   # 学習率

# 勝率の結果を保存するテーブルを生成する
all_rates = np.zeros((runs, steps)) # 試行NO. x １試行の中での強化ステップNO. ※引数はタプル型

for run in range(runs): 
    # バンディットとエージェントのインスタンスを生成する
    bandit = NonStatBandit(arms=actions)
    agent = AlphaAgent(epsilon=epsilon, alpha=alpha, actions=actions)
    
    # 報酬の初期化
    total_reward = 0
    total_rewards = []
    rates = []
    
    for step in range(steps):
        action = agent.get_action() #　行動を選択
        reward = bandit.play(action)# 行動し報酬を得る
        agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

        total_reward += reward
        total_rewards.append(total_reward) 
        rates.append(total_reward / (step + 1))
    
    all_rates[run] = rates # 勝率の結果を保存する

# 非定常バンディット問題をruns = 200回ランダムに解いて平均を見る

#np.random.seed(0)

runs = 200 # モデル数

steps = 1_000 # 学習の更新ステップ数

actions = 10 # 選択可能な「行動」の数

epsilon = 0.1 # 貪欲率

alpha = 0.8 # 学習率

# 勝率の結果を保存するテーブルを生成する

all_rates = np.zeros((runs, steps)) # 試行NO. x １試行の中での強化ステップNO. ※引数はタプル型

for run in range(runs):

# バンディットとエージェントのインスタンスを生成する

bandit = NonStatBandit(arms=actions)

agent = AlphaAgent(epsilon=epsilon, alpha=alpha, actions=actions)

# 報酬の初期化

total_reward = 0

total_rewards = []

rates = []

for step in range(steps):

action = agent.get_action() #　行動を選択

reward = bandit.play(action)# 行動し報酬を得る

agent.update(action=action, reward=reward) # 選択した行動と得た報酬から行動価値を更新する。

total_reward += reward

total_rewards.append(total_reward)

rates.append(total_reward / (step + 1))

all_rates[run] = rates # 勝率の結果を保存する

# 200モデル分
for run in range(runs):
    plt.plot(all_rates[run])
plt.show()

# 200モデル分の平均
average_rates = all_rates.mean(axis=0)
plt.plot(average_rates)
plt.show()

# 200モデル分

for run in range(runs):

plt.plot(all_rates[run])

plt.show()

# 200モデル分の平均

average_rates = all_rates.mean(axis=0)

plt.plot(average_rates)

plt.show()

テスト

これはテストです

とあるバッグ(0001)　幼稚園入学　小学校入学

・内容：すごくいいバックです。

・サイズ：いい感じのサイズです。

・色　：ピンク　ブルー　パープルの三色です。

・材質：めっちゃ頑丈です。

python : pyscript

例

<!DOCTYPE html>
<html lang="ja">
  <head>
    <meta charset="utf-8" />
    <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
    <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
    <py-env>
        - numpy
    </py-env>
  </head>

  <body>
      <h1>pyscript demo</h1>
    <py-script>
import numpy as np

print('すごいことになっている')
print('すごいことになっている')
a = 100+20
print(a)
print(np.random.randn())
    </py-script>
  </body>
</html>

<!DOCTYPE html>

<head>

<py-env>

- numpy

</py-env>

</head>

<body>

<h1>pyscript demo</h1>

<py-script>

import numpy as np

print('すごいことになっている')

a = 100+20

print(a)

print(np.random.randn())

</py-script>

</body>

</html>

python : logging モジュールの使い方

使い方例

#from distutils.debug import DEBUG
#from distutils.log import ERROR, 
from logging import getLogger, FileHandler, StreamHandler
from logging import Formatter
from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL


# ロガー　フォーマッターのオブジェクトを作成する
logger = getLogger(__name__) # ログの出力を命令するオブジェクト
formatter = Formatter('[%(levelname)s] %(asctime)s - %(message)s (%(filename)s)')

# ハンドラーのオブジェクトを作成する
#handler = StreamHandler() # どうやってログの出力をするか操作するオブジェクト、出力実行部分、Pythonの標準出力
handler = FileHandler('log_all.txt') # ファイルにロギングする
handler.setLevel(DEBUG) # ログのレベルの設定　デバッグモード
handler.setFormatter(formatter) # フォーマッターをハンドラーにセットする

error_handler = FileHandler('log_error.txt') # ファイルにロギングする
error_handler.setLevel(ERROR) # ログのレベルの設定 エラーモード
error_handler.setFormatter(formatter) # フォーマッターをエラーハンドラーに設置する

 # ロガーのログのレベルの設定　デバッグモード
logger.setLevel(DEBUG)

# ロガーにハンドラーを追加
logger.addHandler(handler)
logger.addHandler(error_handler)


logger.debug('ここはデバッグログが入る')
logger.info('ここにインフォログが入る')
logger.warning('ここにワーニングログが入る')
logger.error('ここにエラーログが入る')
#logger.critical('ここにクリティカルログが入る')

""" ログレベル
1.DEBUG    -> debug()     :開発中　動きが正しいかの確認　一番低いレベルなので、すべてのログが出力される
2.INFO     -> info()      :正常な動きをしている情報
3.WARNING  -> warning()   :想定外のこと、問題が起きるかもしれないという警告
4.ERROR    -> error()     :問題が起きた
5.CRITICAL -> critivcal() :とても重大な問題が発生

logger.error('XXXXX) -> ログレベルがエラー以上のとき出力されるメッセージ
"""

"""ハンドラーを２つ作ってみる

"""

#from distutils.debug import DEBUG

#from distutils.log import ERROR,

from logging import getLogger, FileHandler, StreamHandler

from logging import Formatter

from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL

# ロガー　フォーマッターのオブジェクトを作成する

logger = getLogger(__name__) # ログの出力を命令するオブジェクト

formatter = Formatter('[%(levelname)s] %(asctime)s - %(message)s (%(filename)s)')

# ハンドラーのオブジェクトを作成する

#handler = StreamHandler() # どうやってログの出力をするか操作するオブジェクト、出力実行部分、Pythonの標準出力

handler = FileHandler('log_all.txt') # ファイルにロギングする

handler.setLevel(DEBUG) # ログのレベルの設定　デバッグモード

handler.setFormatter(formatter) # フォーマッターをハンドラーにセットする

error_handler = FileHandler('log_error.txt') # ファイルにロギングする

error_handler.setLevel(ERROR) # ログのレベルの設定エラーモード

error_handler.setFormatter(formatter) # フォーマッターをエラーハンドラーに設置する

# ロガーのログのレベルの設定　デバッグモード

logger.setLevel(DEBUG)

# ロガーにハンドラーを追加

logger.addHandler(handler)

logger.addHandler(error_handler)

logger.debug('ここはデバッグログが入る')

logger.info('ここにインフォログが入る')

logger.warning('ここにワーニングログが入る')

logger.error('ここにエラーログが入る')

#logger.critical('ここにクリティカルログが入る')

""" ログレベル

1.DEBUG -> debug() :開発中　動きが正しいかの確認　一番低いレベルなので、すべてのログが出力される

2.INFO -> info() :正常な動きをしている情報

3.WARNING -> warning() :想定外のこと、問題が起きるかもしれないという警告

4.ERROR -> error() :問題が起きた

5.CRITICAL -> critivcal() :とても重大な問題が発生

logger.error('XXXXX) -> ログレベルがエラー以上のとき出力されるメッセージ

"""

"""ハンドラーを２つ作ってみる

"""

です。

機械名：号機：顧客番号

取扱説明書