你的DDPG/RDPG為何不收斂？

園子好多年沒有更過了，草長了不少。上次更還是讀博之前，這次再更已是博士畢業2年有余，真是令人唏噓。盜鏈我博客的人又見長，身邊的師弟也問我挖的幾個系列坑什么時候添上。這些著實令我欣喜，看來我寫的東西也是有人樂意看的。去年11月份左右，因為研究需要，了解了一下強化學習（Reinforcement learning）。沒想到這一了解就花了我10個月，看來我又得開新坑了。最近幾個月親自實踐了多種高階的強化學習算法。實踐的過程毫無疑問是痛苦的，我的自信心被某些“細節”反復搓揉，待我決定寫這篇Blog的時候，自信心已經被搓的稀巴爛了。我一貫喜歡在趟雷之后寫Blog，防止被我踩過的雷再崩到別人。如果你此刻也在被DDPG/RDPG的某些細節搓揉，希望這篇博客能幫到你。

根據個人經歷，我把強化學習的學習過程分為幾個層次：

第一層次：RL小白（癥狀：誤以為RL和DL’深度學習’沒什么區別，不過換個算法罷了）

第二層次：學習了RL的基本概念，逐漸抓住RL的本質（序貫決策），但從未運行過RL的程序

第三層次：掌握了RL的大部分主干算法和邏輯，運行過別人寫的RL程序，以為對RL懂得很多了。

第四層次：親自實踐RL的程序，并應對多種不同的類型的Environment，然后驚訝的發現“CNM，為毛算法不收斂？難道我學習的理論錯了？難道我的程序錯了？”

如果你處于第一個層次或者第二個層次，建議你轉去莫煩Python或者是劉建平Pinard補基礎。

如果你處于第三個層次，勸君一句話：“紙上得來終覺淺，覺知此事要躬行”。RL的細節不是一般的多，而且招招致命。這一點和ML/DL真不太一樣。

如果你處于第四個層次，這篇文章希望成為你的答案。

本文分為四個部分：

DDPG不收斂的潛在原因分析
RDPG不收斂的潛在原因分析（含Github上幾個不能收斂的RDPG源碼分析）
D(R)DPG可以收斂的源碼（分Keras和pytorch兩種版本）
強化學習實踐（編程）過程的幾點建議

一：DDPG不收斂的潛在原因分析

先上DDPG的算法偽代碼：

（1）在編寫Q(s, a)的過程中，錯誤的使用了layer.Add層而非layer.concatenate (keras版)或torch.cat (pytorch版)

會導致不收斂的critic代碼如下：

 #程序清單1
 1 from keras.layers import Add
 2 #如下代碼定義了critic網絡
 3 def _build_critic(self, featureDim, actionDim, learningRate=LR_C):
 4         stateInputs = Input(shape = (featureDim, ), name = 'State-Input')
 5         actionInput = Input(shape = (actionDim, ), name = 'Action-Input')
 6         stateOut = Dense(30, activation = 'relu')(stateInputs)
 7         actionOut = Dense(30, activation = 'relu')(actionInput)
 8         Outputs = Add()([stateOut, actionOut])
 9         init = RandomUniform(minval = -0.003, maxval = 0.003)
10         Outputs = Dense(1, activation = 'linear', name = 'Q-Value', kernel_initializer = init)(Outputs)            
11         critic = Model(inputs = [stateInputs, actionInput], outputs = Outputs)
12         return critic

不收斂原因的分析：寫代碼的時候一定要多想想Q(s, a)的本質是什么？Q(s, a)的本質是多鍵值的聯合查表，即采用s和a作為鍵值在一個表格中查表，只不過這個表格用神經網絡替代了。也就是說，作為鍵值，s和a一定要分別單獨給出，而不能加在一起然后再給神經網絡。

可以收斂的critic寫法如下（Keras版）：

#程序清單2
 1 from keras.layers import concatenate
 2 
 3 def _build_critic(self, featureDim, actionDim, learningRate=LR_C):
 4 
 5         sinput = Input(shape=(featureDim,), name='state_input')
 6         ainput = Input(shape=(actionDim,), name='action_input')
 7         s = Dense(40, activation='relu')(sinput)
 8         a = Dense(40, activation='relu')(ainput)
 9         x = concatenate([s, a])
10         x = Dense(40, activation='relu')(x)
11         output = Dense(1, activation='linear')(x)
12 
13         model = Model(inputs=[sinput, ainput], outputs=output)
14         model.compile(loss='mse', optimizer=Adam(lr=learningRate))
15 
16         return model

（2）如果采用PyTorch編寫actor神經網絡，有一點要注意（經筆者實驗，只有PyTorch有這個問題，Keras的coder可以放心的跳過這一節了）

使用PyTorch盡量不要使用Lambda層，實驗結果上來看它似乎非常影響收斂性。盡管Keras上使用Lambda層不影響收斂性。

會導致收斂過程很坎坷甚至不收斂的actor代碼如下：

#程序清單3
 1 class Actor(torch.nn.Module):
 2     def __init__(self, s_dim, a_dim):
 3         super(Actor, self).__init__()
 4         self.Layer1 = torch.nn.Linear(s_dim, 30)   # Input layer
 5         self.Layer2 = torch.nn.Linear(30, 30)
 6         self.Layer3 = torch.nn.Linear(30, a_dim)
 7         self.relu = torch.nn.ReLU()
 8         self.tanh = torch.nn.Tanh()
 9 
10     def forward(self, s_input):
11         out = self.relu(self.Layer1(s_input))          # linear output
12         out = self.relu(self.Layer2(out))
13         out = self.tanh(self.Layer3(out))
14         out = Lambda(lambda x: x * 2)(out)
15         return out

注意到程序的第14行引用了Lambda層，筆者當時解決的問題是“Pendulum-v0”，對于該問題，合法的動作空間是[-2, 2]之間的。而13行的tanh輸出在[-1, 1]之間。所以需要把13行的輸出乘以2。但是筆者發現，這種寫法收斂的過程相較不采用Lambda層而直接將out乘以2（代碼之后給出）輸出收斂的更慢，并且收斂的過程會被反復破壞然后再收斂，如下圖：

上圖的藍線表示critic_loss, 橘線表示實時動作-狀態值函數的預測輸出。可以從上圖（左）看到，在PyTorch中采用Lambda層規范動作值使得critic對動作-狀態值函數的預測難以收斂，這表示它對critic的預測帶來了負面的影響，總是不斷的破壞critic的收斂性。上圖（右）的代碼如程序清單4中所示。直接將上一層網絡的輸出乘以2而沒有使用Lambda層。可見critic的預測可以逐漸趨近于0（對于Pendulum-v0這是收斂，其他環境不趨于0），收斂性也好了很多。

可以收斂的actor寫法如下：

#程序清單4
 1 class Actor(torch.nn.Module):
 2     def __init__(self, s_dim, a_dim):
 3         super(Actor, self).__init__()
 4 
 5         self.l1 = torch.nn.Linear(s_dim, 40)
 6         self.l2 = torch.nn.Linear(40, 30)
 7         self.l3 = torch.nn.Linear(30, a_dim)
 8 
 9     def forward(self, x):
10         x = F.relu(self.l1(x))
11         x = F.relu(self.l2(x))
12         x = 2 * torch.tanh(self.l3(x))
13         return x

（3）如果采用PyTorch編寫critic神經網絡，有一點要注意（經筆者實驗，也是只有PyTorch有這個問題，Keras的coder可以放心的跳過這一節了）

在編寫Q(s, a)的時候，s和a一定要在一開始輸入神經網絡的時候就做連接操作（上文提到的concatenate）而不要讓s和a分別經過一層神經網絡后再做連接操作。否則，critic會不收斂。

會導致不收斂的critic代碼如下：

#程序清單5 
1 class Critic(torch.nn.Module):
 2     def __init__(self, s_dim, a_dim):
 3         super(Critic, self).__init__()
 4         self.Layer1_s = torch.nn.Linear(s_dim, 30)
 5         self.Layer1_a = torch.nn.Linear(a_dim, 30)
 6         self.Layer2 = torch.nn.Linear(30+30, 30)
 7         self.Layer3 = torch.nn.Linear(30, 1)
 8         self.relu = torch.nn.ReLU()  
 9         
10     def forward(self, s_a):
11         s, a = s_a
12         out_s = self.relu(self.Layer1_s(s))
13         out_a = self.relu(self.Layer1_a(a))
14         out = self.relu(self.Layer2(torch.cat([out_s, out_a], dim=-1)))
15         out = self.Layer3(out)
16         return out

上圖的藍線表示critic_loss, 橘線表示實時動作-狀態值函數的預測輸出。上圖（左）是程序清單5運行的結果輸出。上圖（右）是程序清單6運行的結果輸出。

可以收斂的critic寫法如下：

#程序清單6 
 1 class Critic(torch.nn.Module):
 2     def __init__(self, s_dim, a_dim):
 3         super(Critic, self).__init__()
 4 
 5         self.l1 = torch.nn.Linear(s_dim + a_dim, 40)
 6         self.l2 = torch.nn.Linear(40 , 30)
 7         self.l3 = torch.nn.Linear(30, 1)
 8 
 9     def forward(self, x_u):
10         x, u = x_u
11         x = F.relu(self.l1(torch.cat([x, u], 1)))
12         x = F.relu(self.l2(x))
13         x = self.l3(x)
14         return x

posted @ 2024-03-22 23:11 Mario-Chao 閱讀(2327) 評論(0) 收藏舉報

刷新頁面返回頂部

趙小胖的腦科學園地

你的DDPG/RDPG為何不收斂？

公告