homerldqn

View code on Github

#

ප්රමුඛතාඅත්දැකීම් නැවත ධාවනය කිරීමේ බෆරය

මෙයද්විමය අංශ ගසක් භාවිතා කරමින් කඩදාසි ප්රමුඛතා අත්දැකීම් නැවත ධාවනයකරයි.

16importrandom1718importnumpyasnp

#

ප්රමුඛතාඅත්දැකීම් නැවත ධාවනය සඳහා බෆරය

ප්රමුඛතා අත්දැකීම් සාම්පල නැවත ධාවනය කිරීම වැදගත් සංක්රාන්ති නිතර නිතර. සංක්රාන්ති සඳහා ප්රමුඛතාවය දෙනු ලබන්නේ තාවකාලික වෙනස දෝෂය (td දෝෂය), δ.

අපිසම්භාවිතාව i සමඟ සංක්රාන්තිය නියැදි කරන්නෙමු, ප්රමුඛතාවය කොපමණ ප්රමාණයක් භාවිතා කරනවාද යන්න තීරණය කරන අධි-පරාමිතියක් P(i)=∑k​pkα​pi​α​ කොහෙද α ? α=0 ඒකාකාර නඩුවට අනුරූප වේ. pi​ ප්රමුඛතාවය වේ.

සංක්රාන්තියසඳහා තාවකාලික වෙනස pi​=∣δi​∣+ϵ δi​ කොතැනද සමානුපාතික ප්රමුඛතාවය අපි භාවිතා කරමු i.

පාඩුශ්රිතයේ වැදගත්-නියැදීම් (IS) බර wi​=(N1​P(i)1​)β භාවිතා කරමින් ප්රමුඛතා නැවත ධාවනය කිරීමෙන් හඳුන්වා දෙන ලද නැඹුරුව අපි නිවැරදි කරමු. මෙය සම්පූර්ණයෙන්ම වන්දි ගෙවන්නේ කවදාද β=1යන්නයි. ස්ථාවරත්වය maxi​wi​1​ සඳහා අපි බර සාමාන්යකරණය කරමු. පුහුණුව අවසානයේ අභිසාරීතාව කෙරෙහි අපක්ෂපාතී ස්වභාවය වඩාත් වැදගත් වේ. එබැවින් අපි පුහුණුව β අවසන් කිරීම සඳහා වැඩි වෙමු.

ද්විමයඛණ්ඩයේ රුක්

නියැදියසඳහා අවශ්ය වන සමුච්චිත සම්භාවිතාව කාර්යක්ෂමව ගණනය කිරීම සඳහා ∑ki​pkα​ද්විමය ඛණ්ඩක ගසක් භාවිතා කරමු. ඒ වගේම අපි සොයා ගැනීමට ද්විමය කොටස ගසක් භාවිතා minpi​α, සඳහා අවශ්ය වන maxi​wi​1​. මේ සඳහා අපට කුඩා ගොඩක් භාවිතා කළ හැකිය. ද්විමය ඛණ්ඩයේ ගස අපට O(logn) කාලය තුළ මෙම ගණනය කිරීමට ඉඩ දෙයි, එය බොළඳ O(n) ප්රවේශය වඩාත් කාර්යක්ෂම වේ.

ද්විමයඛණ්ඩක ගසක් එකතුව සඳහා ක්රියා කරන ආකාරය මෙයයි; එය අවම වශයෙන් සමාන වේ. අපි නියෝජනය කිරීමට අවශ්ය N වටිනාකම් ලැයිස්තුව කරමු xi​ . ද්විමය ගසෙහි ith පේළියේ jth නෝඩය bi,j​ විය යුතුය. ඒ node එකක් මතම ඊට අදාල දරුවන් දෙදෙනෙකු bi,j​ වන bi+1,2j​ අතර bi+1,2j+1​.

පේළියේකොළ නෝඩ් වල අගයන් D=⌈1+log2​N⌉ ඇත x. සෑම නෝඩයක්ම ළමා නෝඩ් දෙකේ එකතුව තබා ගනී. එනම්, මූල නෝඩය සමස්ත අගයන්හි එකතුව තබා ගනී. මූල node එකක් මතම ඊට අදාල වම් හා දකුණු දරුවන් පිළිවෙළින් අරාවෙහි පළමු භාගයේ එකතුව සහ දෙවන භාගයේ එකතුව තබා ගන්න. හා එසේ මත...

bi,j​=k=(j−1)∗2D−i+1∑j∗2D−i​xk​

පේළියේනෝඩ් ගණන i, Ni​=⌈D−i+1N​⌉ මෙය ඉහත සියලු පේළිවල නෝඩ් එකතුවට සමාන වේ i. ඒ නිසා අපට ගස ගබඩා a කිරීම සඳහා තනි අරාවක් භාවිතා කළ හැකිය, කොහේද, bi,j​→aNi​+j​

එවිටළමා නෝඩ් ai​ a2i​ සහ a2i+1​. එනම්, ai​=a2i​+a2i+1​

ද්විමයගස් නඩත්තු කිරීමේ මෙම ක්රමය ක්රමලේඛනය කිරීම ඉතා පහසුය. අපිසුචිගත කිරීම 1 සිට ආරම්භ වන බව සලකන්න.

අවමගණනය කිරීම සඳහා අපි එකම ව්යුහය භාවිතා කරමු.

21classReplayBuffer:

#

ආරම්භකරන්න

91def\_\_init\_\_(self,capacity,alpha):

#

අපිධාරිතාව 2 සඳහා බලයක් භාවිතා කරන්නේ එය කේතය සහ නිදොස්කරණය සරල කරන බැවිනි

96self.capacity=capacity

#

α

98self.alpha=alpha

#

මුදලක්ගැනීමට සහ පරාසයක් පුරා අවම සොයා ගැනීමට කොටස ද්විමය ගස් පවත්වා

101self.priority\_sum=[0for\_inrange(2\*self.capacity)]102self.priority\_min=[float('inf')for\_inrange(2\*self.capacity)]

#

වත්මන්උපරිම ප්රමුඛතාවය p,, නව සංක්රාන්ති සඳහා පැවරිය යුතුය

105self.max\_priority=1.

#

බෆරයසඳහා අරා

108self.data={109'obs':np.zeros(shape=(capacity,4,84,84),dtype=np.uint8),110'action':np.zeros(shape=capacity,dtype=np.int32),111'reward':np.zeros(shape=capacity,dtype=np.float32),112'next\_obs':np.zeros(shape=(capacity,4,84,84),dtype=np.uint8),113'done':np.zeros(shape=capacity,dtype=np.bool)114}

#

දත්තගබඩා කිරීම සඳහා අපි චක්රීය බෆර් භාවිතා කරන අතර ඊළඟ හිස් තට්ටුවේ දර්ශකය next_idx තබා ගනිමු

117self.next\_idx=0

#

බෆරයේප්රමාණය

120self.size=0

#

පෝලිමටනියැදිය එක් කරන්න

122defadd(self,obs,action,reward,next\_obs,done):

#

ඊළඟලබාගත හැකි තව් ලබා ගන්න

128idx=self.next\_idx

#

පෝලිමේගබඩා

131self.data['obs'][idx]=obs132self.data['action'][idx]=action133self.data['reward'][idx]=reward134self.data['next\_obs'][idx]=next\_obs135self.data['done'][idx]=done

#

ඊළඟලබා ගත හැකි තව් වැඩි කිරීම

138self.next\_idx=(idx+1)%self.capacity

#

ප්රමාණයගණනය කරන්න

140self.size=min(self.capacity,self.size+1)

#

pi​α, නව සාම්පල ලබා max_priority

143priority\_alpha=self.max\_priority\*\*self.alpha

#

එකතුවසහ අවම වශයෙන් කොටස් ගස් දෙක යාවත්කාලීන කරන්න

145self.\_set\_priority\_min(idx,priority\_alpha)146self.\_set\_priority\_sum(idx,priority\_alpha)

#

අවමසඳහා ද්විමය කොටස ගස ප්රමුඛත්වය සකසන්න

148def\_set\_priority\_min(self,idx,priority\_alpha):

#

ද්විමයගසෙහි කොළ

154idx+=self.capacity155self.priority\_min[idx]=priority\_alpha

#

මුතුන්මිත්තන් ඔස්සේ ගමන් කිරීමෙන් ගස යාවත්කාලීන කරන්න. ගසේ මුල තෙක් දිගටම කරගෙන යන්න.

159whileidx\>=2:

#

මව්නෝඩයේ දර්ශකය ලබා ගන්න

161idx//=2

#

මව්node එකක් මතම ඊට අදාල වටිනාකම එය දරුවන් දෙදෙනා අවම වේ

163self.priority\_min[idx]=min(self.priority\_min[2\*idx],self.priority\_min[2\*idx+1])

#

මුදලසඳහා ද්විමය කොටස ගස ප්රමුඛත්වය සකසන්න

165def\_set\_priority\_sum(self,idx,priority):

#

ද්විමයගසෙහි කොළ

171idx+=self.capacity

#

කොළයේප්රමුඛතාවය සකසන්න

173self.priority\_sum[idx]=priority

#

මුතුන්මිත්තන් ඔස්සේ ගමන් කිරීමෙන් ගස යාවත්කාලීන කරන්න. ගසේ මුල තෙක් දිගටම කරගෙන යන්න.

177whileidx\>=2:

#

මව්නෝඩයේ දර්ශකය ලබා ගන්න

179idx//=2

#

මව්node එකක් මතම ඊට අදාල වටිනාකම එය දරුවන් දෙදෙනා එකතුව

181self.priority\_sum[idx]=self.priority\_sum[2\*idx]+self.priority\_sum[2\*idx+1]

#

∑k​pkα​

183def\_sum(self):

#

මූලනෝඩය සියලු අගයන්හි එකතුව තබා ගනී

189returnself.priority\_sum[1]

#

mink​pkα​

191def\_min(self):

#

මූලනෝඩය සියලු අගයන්හි අවම වශයෙන් තබා ගනී

197returnself.priority\_min[1]

#

i එවැනි විශාලතම සොයා ∑k=1i​pkα​≤P

199deffind\_prefix\_sum\_idx(self,prefix\_sum):

#

මූලසිට ආරම්භ කරන්න

205idx=1206whileidx\<self.capacity:

#

වම්ශාඛාවේ එකතුව අවශ්ය ප්රමාණයට වඩා වැඩි නම්

208ifself.priority\_sum[idx\*2]\>prefix\_sum:

#

ගසෙහිවම් ශාඛාවට යන්න

210idx=2\*idx211else:

#

එසේනොමැතිනම් දකුණු ශාඛාවට ගොස් වම් ශාඛාවේ එකතුව අවශ්ය මුදලින් අඩු කරන්න

214prefix\_sum-=self.priority\_sum[idx\*2]215idx=2\*idx+1

#

අපිකොළ node එකක් මතම ඊට අදාල වේ. සැබෑ වටිනාකමේ දර්ශකය ලබා ගැනීම සඳහා ගසෙහි දර්ශකය මගින් ධාරිතාව අඩු කිරීම

219returnidx-self.capacity

#

බෆරයෙන්නියැදිය

221defsample(self,batch\_size,beta):

#

සාම්පලආරම්භ කරන්න

227samples={228'weights':np.zeros(shape=batch\_size,dtype=np.float32),229'indexes':np.zeros(shape=batch\_size,dtype=np.int32)230}

#

නියැදිදර්ශක ලබා ගන්න

233foriinrange(batch\_size):234p=random.random()\*self.\_sum()235idx=self.find\_prefix\_sum\_idx(p)236samples['indexes'][i]=idx

#

mini​P(i)=∑k​pkα​mini​pi​α​

239prob\_min=self.\_min()/self.\_sum()

#

maxi​wi​=(N1​mini​P(i)1​)β

241max\_weight=(prob\_min\*self.size)\*\*(-beta)242243foriinrange(batch\_size):244idx=samples['indexes'][i]

#

P(i)=∑k​pkα​pi​α​

246prob=self.priority\_sum[idx+self.capacity]/self.\_sum()

#

wi​=(N1​P(i)1​)β

248weight=(prob\*self.size)\*\*(-beta)

#

සාමාන්යකරණයකරන්න maxi​wi​1​, එමඟින් N1​ පදය අවලංගු වේ

251samples['weights'][i]=weight/max\_weight

#

සාම්පලදත්ත ලබා ගන්න

254fork,vinself.data.items():255samples[k]=v[samples['indexes']]256257returnsamples

#

ප්රමුඛතායාවත්කාලීන කරන්න

259defupdate\_priorities(self,indexes,priorities):

#

264foridx,priorityinzip(indexes,priorities):

#

වත්මන්උපරිම ප්රමුඛතාවය සකසන්න

266self.max\_priority=max(self.max\_priority,priority)

#

ගණනයකරන්න pi​α

269priority\_alpha=priority\*\*self.alpha

#

ගස්යාවත්කාලීන කරන්න

271self.\_set\_priority\_min(idx,priority\_alpha)272self.\_set\_priority\_sum(idx,priority\_alpha)

#

බෆරයපිරී තිබේද

274defis\_full(self):

#

278returnself.capacity==self.size

Trending Research Paperslabml.ai