Comment comprendre l'algorithme d'optimisation de stratégie proximale en RL?

Question

Je connais les bases de l'apprentissage par renforcement, mais quels termes faut-il comprendre pour pouvoir lire le papier arxiv PPO ?

Quelle est la feuille de route pour apprendre et utiliser PPO ?

Answer 1

PPO, et notamment TRPO tente de mettre à jour la politique conservatrice, sans altérer ses performances défavorable entre chaque mise à jour des politiques.

Pour ce faire, vous avez besoin d'un moyen de mesurer combien la politique a changé après chaque mise à jour. Cette mesure est faite en regardant le KL divergence entre la mise à jour de la politique et de la vieille politique.

Cela devient une contrainte du problème d'optimisation, nous voulons changer la politique dans le sens de la performance maximale, suivant les contraintes que le KL divergence entre ma nouvelle politique et les vieux ne dépassent pas certains pré-définies (ou adaptative) de seuil.

Avec TRPO, on calcule le KL contrainte lors de la mise à jour et trouve le taux d'apprentissage pour ce problème (par l'intermédiaire de la Matrice de Fisher et du gradient conjugué). C'est un peu salissant à mettre en œuvre.

Avec la PPO, nous simplifier le problème en tournant la divergence KL à partir d'une contrainte à une peine de durée, semblable par exemple à L1, L2 peine de poids (pour éviter un poids croissant de grandes valeurs). PPO fait des modifications supplémentaires en supprimant la nécessité de calculer la divergence KL tous ensemble, par dur écrêtage de la politique (ratio de mise à jour de la politique à l'ancienne) à l'intérieur d'une petite plage autour de 1,0 où 1,0 signifie que la nouvelle politique est la même que les anciens.

Answer 2

PPO est un algorithme simple, qui s'inscrit dans la politique d'optimisation des algorithmes de la classe (par opposition à la valeur basée sur des méthodes telles que DQN). Si vous "savez" RL bases (je veux dire, si vous avez au moins lu un air pensif quelques premiers chapitres de Sutton livre par exemple), puis une première étape logique est de se familiariser avec la politique de gradient algorithmes. Vous pouvez lire ce livre ou chapitre 13 de Sutton du livre de la nouvelle édition. En outre, vous pouvez aussi lire ce papier sur TRPO, qui est un travail précédent de la PPO du premier auteur (ce papier a de nombreuses erreurs de notation, il suffit de noter). Espérons que cela aide. --Mehdi

Answer 3

Je pense que la mise en œuvre pour une action discrète de l'espace tels que Cartpole-v1 est plus facile que par l'action continue des espaces. Mais pour l'action continue des espaces, c'est la plus straight-forward de la mise en œuvre que j'ai trouvé dans Pytorch comme vous pouvez le voir clairement comment ils obtiennent mu et std où que je ne pourrais pas avec la plus célèbre des implémentations comme Openai lignes de base et de le faire tourner ou Stable lignes de base.

RL-l'Aventure de la PPO

Ces lignes à partir du lien ci-dessus:

class ActorCritic(nn.Module):
    def __init__(self, num_inputs, num_outputs, hidden_size, std=0.0):
        super(ActorCritic, self).__init__()

        self.critic = nn.Sequential(
            nn.Linear(num_inputs, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, 1)
        )

        self.actor = nn.Sequential(
            nn.Linear(num_inputs, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, num_outputs),
        )
        self.log_std = nn.Parameter(torch.ones(1, num_outputs) * std)

        self.apply(init_weights)

    def forward(self, x):
        value = self.critic(x)
        mu    = self.actor(x)
        std   = self.log_std.exp().expand_as(mu)
        dist  = Normal(mu, std)
        return dist, value

et la coupure:

def ppo_update(ppo_epochs, mini_batch_size, states, actions, log_probs, returns, advantages, clip_param=0.2):
    for _ in range(ppo_epochs):
        for state, action, old_log_probs, return_, advantage in ppo_iter(mini_batch_size, states, actions, log_probs, returns, advantages):
            dist, value = model(state)
            entropy = dist.entropy().mean()
            new_log_probs = dist.log_prob(action)

            ratio = (new_log_probs - old_log_probs).exp()
            surr1 = ratio * advantage
            surr2 = torch.clamp(ratio, 1.0 - clip_param, 1.0 + clip_param) * advantage

J'ai trouvé le lien ci-dessus les commentaires sur cette vidéo sur Youtube:

arxiv idées PPO