続く
`` `
    def worward（self、x）：
        x = torch.relu（self.fc1（x））
        x = torch.softmax（self.fc2（x）、dim = -1）
        xを返します


DEF PPO_LOSS（比率、アドバンテージ、CLIP_RATIO、エントロピー、C1、C2）：
    PG_LOSS = TORCH.MIN（比率 * Advantage、Torch.Clamp（比率、1-Clip_ratio、1+Clip_ratio） *アドバンテージ）
    vf_loss = torch.square（比率-1.0） *アドバンテージ
    Entropy_loss = -C2 *エントロピー
    loss = -pg_loss + c1 * vf_loss + entropy_loss
    return loss.mean（）


クラスPPO：
    def __ init __（self、state_size、action_size、hidden_​​size = 64、clip_ratio = 0.2、c1 = 1.0、c2 = 0.01、gamma = 0.99、lam = 0.95、lr = 3e-4）
        self.actor = mlp（state_size、hidden_​​size、action_size）
        self.critic = mlp（state_size、hidden_​​size、1）
        self.optimizer = optimadam（list（self.actor.parameters（））+list（self.cripic.parameters（））、lr = lr）
        self.clip_ratio = clip_ratio
        self.c1 = c1
        self.c2 = c2
        self.gamma =ガンマ
        self.lam = lam
        
    def selection_action（seld、state）：
        state = torch.tensor（state、dtype = torch.float32）.squeeze（0）
        action_probs = self.actor（state）
        dist = torch.distributions.categorical（action_probs）
        action = dist.sample（）
        return Action.item（）、dist.log_prob（action）、differyropy（）（）（）
    
    def evaluate（自己、状態、行動）：
        action_probs = self.actor（stathes）
        dist = torch.distributions.categorical（action_probs）
        log_probs = dist.log_prob（アクション）
        エントロピー= dist.entropy（）
        values = self.critic（状態）
        log_probs、エントロピー、値を返します
        
    def Train（自己、状態、アクション、報酬、next_states、マスク）：
        states = torch.tensor（states、dtype = torch.float32）
        アクション= torch.tensor（actions、dtype = torch.int32）
        rewards = torch.tensor（rewards、dtype = torch.float32）

        _、_、values = self.evaluate（状態、行動）
        _、_、next_values = self.evaluate（next_states、actions）
        deltas = rewards + self.gamma *マスク * next_values -values
        利点= compute_advantage（deltas、masks、self.gamma、self.lam）

        _ in range（num_epochs）：
            インデックス= torch.randperm（stathes.size（0））
            範囲の開始（0、states.size（0）、batch_size）：
                end = min（start + batch_size、states.size（0）））
                mini_batch_indices = indices [start：end]
                mini_batch_states = states [mini_batch_indices]
                mini_batch_actions = actions [mini_batch_indices]
                mini_batch_advantages =利点[mini_batch_indices]
                mini_batch_old_log_probs、mini_batch_entropy、_ = self.evaluate（mini_batch_states、mini_batch_actions）
                _ in range（num_mini_batches）：
                    mini_batch_indices = torch.randperm（mini_batch_states.size（0））
                    範囲で開始する場合（0、mini_batch_states.size（0）、mini_batch_size）：
                        end = min（start + mini_batch_size、mini_batch_states.size（0））
                        mini_batch_indices_ = mini_batch_indices [start：end]
                        mini_batch_states_ = mini_batch_states [mini_batch_indices_]
                        mini_batch_actions_ = mini_batch_actions [mini_batch_indices_]
                        mini_batch_advantages_ = mini_batch_advantages [mini_batch_indices_]
                        mini_batch_old_log_probs_、mini_batch_entropy_、mini_batch_values_ = self.evaluate
                        比率= torch.exp（mini_batch_old_log_probs_ -mini_batch_log_probs.detach（））
                        loss = ppo_loss（比率、mini_batch_advantages_、self.clip_ratio、mini_batch_entropy_、self.c1、self.c2）
                        self.optimizer.zero_grad（）
                        loss.backward（）
                        self.optimizer.step（）


def compute_advantage（deltas、masks、mamma、lam）：
    利点= torch.zeros_like（deltas）
    last_advantage = 0
    逆のtの場合（範囲（deltas.size（0））:)：
        t == deltas.size（0）-1の場合：
            next_non_terminal = 1.0 -masks [-1]
            next_value = last_advantage = deltas [-1] + next_non_terminal * last_advantage * gamma
        それ以外：
            next_non_terminal = 1.0 -masks [t]
            next_value = last_advantage = deltas [t] + next_non_terminal * last_advantage * gamma * lam
        利点[t] = next_value -self.cribeic（stathes [t]）
    利点を返します
`` `