利用PyTorch實現爬山算法

Posted on by

0. 前言

在隨機搜索策略中，每個回合都是獨立的。因此，隨機搜索中的所有回合都可以並行運行，最終選擇能夠得到最佳性能的權重。我們還通過繪制總獎勵隨回合增加的變化情況進行驗證，可以看到獎勵並沒有上升的趨勢。在本節中，我們將實現爬山算法 (hill-climbing algorithm)，以將在一個回合中學習到的知識轉移到下一個回合中。

1. 使用 PyTorch 實現爬山算法

1.1 爬山算法簡介

在爬山算法中，我們同樣從隨機選擇的權重開始。但是，對於每個回合，我們都會為權重添加一些噪聲數據。如果總獎勵有所改善，我們將使用新的權重來更新原權重；否則，將保持原權重。通過這種方法，隨著回合的增加，權重也會逐步修改，而不是在每個回合中隨機改變。

1.2 使用爬山算法進行 CartPole 遊戲

接下來，我們使用 PyTorch 實現爬山算法。首先，導入所需的包，創建一個 CartPole 環境實例，並計算狀態空間和動作空間的尺寸。重用 run_episode 函數，其會根據給定權重，模擬一個回合後返回總獎勵：

import gym
import torch
from matplotlib import pyplot as plt
env = gym.make('CartPole-v0')

n_state = env.observation_space.shape[0]
print(n_state)

n_action = env.action_space.n
print(n_action)

def run_episode(env, weight):
    state = env.reset()
    total_reward = 0
    is_done = False
    while not is_done:
        state = torch.from_numpy(state).float()
        action = torch.argmax(torch.matmul(state, weight))
        state, reward, is_done, _ = env.step(action.item())
        total_reward += reward
    return total_reward

模擬 1000 個回合，並初始化變量用於跟蹤最佳的總獎勵以及相應的權重。同時，初始化一個空列表用於記錄每個回合的總獎勵：

n_episode = 1000
best_total_reward = 0
best_weight = torch.randn(n_state, n_action)

total_rewards = []

正如以上所述，我們在每個回合中為權重添加一些噪音，為瞭使噪聲不會覆蓋原權重，我們還將對噪聲進行縮放，使用 0.01 作為噪聲縮放因子：

noise_scale = 0.01

然後，就可以運行 run_episode 函數進行模擬。

隨機選擇初始權重之後，在每個回合中執行以下操作：

  • 為權重增加隨機噪音
  • 智能體根據線性映射采取動作
  • 回合終止並返回總獎勵
  • 如果當前獎勵大於到目前為止獲得的最佳獎勵，更新最佳獎勵和權重；否則，最佳獎勵和權重將保持不變
  • 記錄每回合的總獎勵
for e in range(n_episode):
    weight = best_weight + noise_scale * torch.rand(n_state, n_action)
    total_reward = run_episode(env, weight)
    if total_reward >= best_total_reward:
        best_total_reward = total_reward
        best_weight = weight
    total_rewards.append(total_reward)
print('Episode {}: {}'.format(e + 1, total_reward))

計算使用爬山算法所獲得的平均總獎勵：

print('Average total reward over {} episode: {}'.format(n_episode, sum(total_rewards) / n_episode))
# Average total reward over 1000 episode: 62.421

2. 改進爬山算法

為瞭評估使用爬山算法的訓練效果，多次重復訓練過程，使用循環語句多次執行爬山算法，可以觀察到平均總獎勵的波動變化較大：

for i in range(10):
    best_total_reward = 0
    best_weight = torch.randn(n_state, n_action)
    total_rewards = []
    for e in range(n_episode):
        weight = best_weight + noise_scale * torch.rand(n_state, n_action)
        total_reward = run_episode(env, weight)
        if total_reward >= best_total_reward:
            best_total_reward = total_reward
            best_weight = weight
        total_rewards.append(total_reward)
        # print('Episode {}: {}'.format(e + 1, total_reward))

print('Average total reward over {} episode: {}'.format(n_episode, sum(total_rewards) / n_episode))

以下是我們運行10次後得到的結果：

Average total reward over 1000 episode: 200.0
Average total reward over 1000 episode: 9.846
Average total reward over 1000 episode: 82.1
Average total reward over 1000 episode: 9.198
Average total reward over 1000 episode: 9.491
Average total reward over 1000 episode: 9.073
Average total reward over 1000 episode: 149.421
Average total reward over 1000 episode: 49.584
Average total reward over 1000 episode: 8.827
Average total reward over 1000 episode: 9.369

產生如此差異的原因是什麼呢？如果初始權重較差，則添加的少量噪聲隻會小范圍改變權重，且對改善性能幾乎沒有影響，導致算法收斂性能不佳。另一方面，如果初始權重較為合適，則添加大量噪聲可能會大幅度改變權重，使得權重偏離最佳權重並破壞算法性能。為瞭使爬山算法的訓練更穩定，我們可以使用自適應噪聲縮放因子，類似於梯度下降中的自適應學習率，隨著模型性能的提升改變噪聲縮放因子的大小。

為瞭使噪聲具有自適應性，執行以下操作：

  • 指定初始噪聲縮放因子
  • 如果回合中的模型性能有所改善，則減小噪聲縮放因子，本節中，每次將噪聲縮放因子減小為原來的一半，同時設置縮放因子最小值為 0.0001
  • 而如果回合中中的模型性能下降，則增大噪聲縮放因子，本節中，每次將噪聲縮放因子增大為原來的 2 倍，同時設置縮放因子最大值為 2
noise_scale = 0.01
best_total_reward = 0
best_weight = torch.randn(n_state, n_action)
total_rewards = []
for e in range(n_episode):
    weight = best_weight + noise_scale * torch.rand(n_state, n_action)
    total_reward = run_episode(env, weight)
    if total_reward >= best_total_reward:
        best_total_reward = total_reward
        best_weight = weight
        noise_scale = max(noise_scale/2, 1e-4)
    else:
        noise_scale = min(noise_scale*2, 2)
    total_rewards.append(total_reward)
    print('Episode {}: {}'.format(e + 1, total_reward))

可以看到，獎勵隨著回合的增加而增加。訓練過程中，當一個回合中可以運行 200 個步驟時，模型的性能可以得到保持，平均總獎勵也得到瞭極大的提升：

print('Average total reward over {} episode: {}'.format(n_episode, sum(total_rewards) / n_episode))
# Average total reward over 1000 episode: 196.28

接下來，為瞭更加直觀的觀察，我們繪制每個回合的總獎勵的變化情況，如下所示，可以看到總獎勵有明顯的上升趨勢，然後穩定在最大值處：

plt.plot(total_rewards, label='search')
plt.xlabel('episode')
plt.ylabel('total_reward')
plt.legend()
plt.show()

多次運行訓練過程過程，可以發現與采用恒定噪聲縮放因子進行學習相比，自適應噪聲縮放因子可以得到穩定的訓練結果。

接下來，我們測試所得到的模型策略在 1000 個新回合中的性能表現：

n_episode_eval = 1000
total_rewards_eval = []
for episode in range(n_episode_eval):
    total_reward = run_episode(env, best_weight)
    print('Episode {}: {}'.format(episode+1, total_reward))
    total_rewards_eval.append(total_reward)

print('Average total reward over {} episode: {}'.format(n_episode_eval, sum(total_rewards_eval)/n_episode_eval))
# Average total reward over 1000 episode: 199.98

可以看到在測試階段的平均總獎勵接近 200，即 CartPole 環境中可以獲得的最高獎勵。通過多次運行評估，可以獲得非常一致的結果。

到此這篇關於利用PyTorch實現爬山算法的文章就介紹到這瞭,更多相關PyTorch爬山算法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：