#

ගැඹුරුQ ජාල (DQN)

මෙය PyTorch ක්රියාත්මක කිරීමකි Atari කඩදාසි සෙල්ලම් කිරීම ගැඹුරු ශක්තිමත් කිරීමේ ඉගෙනීම සහ ඩුවලිං ජාලය , ප්රමුඛතා නැවත ධාවනය සහ ද්විත්ව Q ජාලය සමඟ.

මෙන්න අත්හදා බැලීම සහ ආදර්ශ ක්රියාත්මක කිරීම.

25from typing import Tuple
26
27import torch
28from torch import nn
29
30from labml import tracker
31from labml_helpers.module import Module
32from labml_nn.rl.dqn.replay_buffer import ReplayBuffer

#

ආකෘතිය පුහුණු කරන්න

ප්රශස්ත ක්රියාකාරී අගය ශ්රිතය සොයා ගැනීමට අපට අවශ්යය.

Q^{*} (s, a) Q^{*} (s, a) = π max E [r_{t} + γ r_{t + 1} + γ^{2} r_{t + 2} + ...∣ s_{t} = s, a_{t} = a, π] = E_{s^{'} \sim ε} [r + γ a^{'} max Q^{*} (s^{'}, a^{'}) ∣ s, a]

ඉලක්ක ජාලය 🎯

ස්ථාවරත්වය වැඩි දියුණු කිරීම සඳහා අපි පෙර අත්දැකීම් වලින් අහඹු ලෙස නියැදිය අත්දැකීම් නැවත ධාවනය භාවිතා කරමු $U (D)$ . ඉලක්කය ගණනය කිරීම සඳහා වෙනම පරාමිතීන් $θ_{i}^{-}$ සමූහයක් සහිත Q ජාලයක් ද අපි භාවිතා කරමු. $θ_{i}^{-}$ වරින් වර යාවත්කාලීන වේ. මෙය ගැඹුරු ශක්තිමත් කිරීමේ ඉගෙනීම තුළින් කඩදාසි මානව මට්ටම් පාලනයට අනුව ය.

එබැවින් පාඩු ශ්රිතය වන්නේ, $L_{i} (θ_{i}) = E_{(s, a, r, s^{'}) \sim U (D)} [(r + γ a^{'} max Q (s^{'}, a^{'}; θ_{i}^{-}) - Q (s, a; θ_{i}))^{2}]$

$Q$ ද්විත්ව-ඉගෙනුම්

ඉහත ගණනය කිරීමේ උපරිම ක්රියාකරු හොඳම ක්රියාව තෝරා ගැනීම සහ වටිනාකම ඇගයීම සඳහා එකම ජාලයක් භාවිතා කරයි. එනම්, $a^{'} max Q (s^{'}, a^{'}; θ) = Q (s^{'}, a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ); θ)$ අපි ද්විත්ව Q- ඉගෙනීම භාවිතා කරමු, $a r gm a x$ එය ලබා ගන්නේ කොතැනින්ද $θ_{i}$ සහ වටිනාකම ලබා $θ_{i}^{-}$ ගනී.

පාඩු ශ්රිතය බවට පත්වේ,

L_{i} (θ_{i}) = E_{(s, a, r, s^{'}) \sim U (D)} [(- r + γ Q (s^{'}, a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ_{i}); θ_{i}^{-}) Q (s, a; θ_{i}))^{2}]

35class QFuncLoss(Module):

#

103    def __init__(self, gamma: float):
104        super().__init__()
105        self.gamma = gamma
106        self.huber_loss = nn.SmoothL1Loss(reduction='none')

#

q - $Q (s; θ_{i})$
action - $a$
double_q - $Q (s^{'}; θ_{i})$
target_q - $Q (s^{'}; θ_{i}^{-})$
done - පියවර ගැනීමෙන් පසු ක්රීඩාව අවසන් වූවාද යන්න
reward - $r$
weights - ප්රමුඛතාවය පළපුරුදු නැවත ධාවනය සිට සාම්පල බර

108    def forward(self, q: torch.Tensor, action: torch.Tensor, double_q: torch.Tensor,
109                target_q: torch.Tensor, done: torch.Tensor, reward: torch.Tensor,
110                weights: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:

#

$Q (s, a; θ_{i})$

122        q_sampled_action = q.gather(-1, action.to(torch.long).unsqueeze(-1)).squeeze(-1)
123        tracker.add('q_sampled_action', q_sampled_action)

#

අනුක්රමිකඅනුක්රමික ප්රචාරය නොකළ යුතුය $r + γ Q (s^{'}, a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ_{i}); θ_{i}^{-})$

131        with torch.no_grad():

#

රාජ්යයෙන්හොඳම ක්රියාව ලබා ගන්න $s^{'}$ $a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ_{i})$

135            best_next_action = torch.argmax(double_q, -1)

#

රාජ්යහොඳම ක්රියාව සඳහා ඉලක්ක ජාලයෙන් q අගය ලබා ගන්න $s^{'}$ $Q (s^{'}, a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ_{i}); θ_{i}^{-})$

141            best_next_q_value = target_q.gather(-1, best_next_action.unsqueeze(-1)).squeeze(-1)

#

අපේක්ෂිතQ අගය ගණනය කරන්න. ක්රීඩාව අවසන් වූයේ නම් ඊළඟ රාජ්ය Q අගයන් ශුන්ය (1 - done) කිරීමට අපි ගුණ කරමු.

$r + γ Q (s^{'}, a r gm a x_{a^{'}} Q (s^{'}, a^{'}; θ_{i}); θ_{i}^{-})$

152            q_update = reward + self.gamma * best_next_q_value * (1 - done)
153            tracker.add('q_update', q_update)

#

නැවතධාවනය කිරීමේ බෆරයේ සාම්පල කිරා මැන බැලීමට තාවකාලික වෙනස දෝෂය $δ$ භාවිතා කරයි

156            td_error = q_sampled_action - q_update
157            tracker.add('td_error', td_error)

#

එයoutliers අඩු සංවේදී නිසා අපි ඒ වෙනුවට මධ්යන්ය වර්ග දෝෂයක් අහිමි Huber අහිමි ගත

161        losses = self.huber_loss(q_sampled_action, q_update)

#

බරතැබූ ක්රම ලබා ගන්න

163        loss = torch.mean(weights * losses)
164        tracker.add('loss', loss)
165
166        return td_error, loss

ගැඹුරුQ ජාල (DQN)

ආකෘතිය පුහුණු කරන්න

ඉලක්ක ජාලය 🎯

Qද්විත්ව-ඉගෙනුම්

$Q$ ද්විත්ව-ඉගෙනුම්