Renforcer les dossiers de base de l'apprentissage

Multi - agent Enhancement Learning LITTLE WHITE one,J'ai récemment appris à renforcer les bases de l'apprentissage,Notez ici,Au cas où.

Un.、Q-learning

Q-learingL'algorithme d'apprentissage intensif le plus élémentaire,AdoptionQÉtat de stockage du tableau-Valeur de l'action,C'est - à - dire:Q(s,a),Peut être utilisé pour les problèmes avec un espace d'état plus petit,Quand la dimension spatiale de l'état est grande,Besoin de coordination avec le réseau neuronal,S'étend àDQNAlgorithmes,Résolution des problèmes.

1. Value-based
2. Off-Policy
     J'ai beaucoup lu surOn-PolicyEtOff-PolicyBlog de,Je n'ai jamais vraiment compris la différence,C'est un peu confus,J'ai lu la réponse d'un blogueur l'autre jour,Pour avoir une meilleure compréhension,Lien ci - joint.
   
   Liens: on-policyEtoff-policyQuelle est la différence?？
   
     QuandQ-learningLors de la mise à jour,Bien que les données utilisées soient actuellespolicyProduit,Mais la politique mise à jour n'est pas celle qui produit ces données（Notez la mise à jour demax）,C'est compréhensible ici：Ici.maxL'opération est de sélectionner pour obtenir un plus grandQAction de la valeur,Mise à jourQTableau, Mais il n'est pas certain que le vrai tour prenne des changements ,Alors c'estOff-PolicyDe.
3. Pseudo - Code
   
4. Réalisation
      L'environnement utilisé ici est le jeu de chasse au trésor dans le tutoriel du professeur mofan , Tenue à jour par liste ,—#-T, La dernière position TC'est un trésor.,# Représente la position actuelle du joueur , Allez à l'extrême droite ,Trouver un trésor,Fin du jeu.
      L'implémentation du Code fait référence à un blogueur , Aucun lien trouvé .....

import numpy as np
import pandas as pd
import time

N_STATES = 6  # 6Statut,Longueur du tableau unidimensionnel
ACTIONS = [-1, 1]  # Deux états,-1：left, 1:right
epsilon = 0.9  # greedy
alpha = 0.1  # Taux d'apprentissage
gamma = 0.9  # Valeur décroissante de la récompense
max_episodes = 10  #  Nombre maximum de Tours 
fresh_time = 0.3  #  Intervalle de déplacement 

# q_table
q_table = pd.DataFrame(np.zeros((N_STATES, len(ACTIONS))), columns=ACTIONS)


# choose action: 1.  Explorer au hasard et explorer des endroits qui n'ont pas été explorés ,Sinon, sélectionnezrewardLe plus grand mouvement
def choose_action(state, table):
    state_actions = table.iloc[state, :]
    if np.random.uniform() > epsilon or state_actions.all() == 0:
        action = np.random.choice(ACTIONS)
    else:
        action = state_actions.argmax()
    return action


def get_env_feedback(state, action):
	#Nouveau statut = État actuel + État du Mouvement
    new_state = state + action
    reward = 0
    # Déplacer à droite plus 0.5
    #À droite., Plus près du Trésor ,Obtenir+0.5Récompenses
    if action > 0:
        reward += 0.5
    #À gauche., Loin du Trésor ,Obtenir-0.5Récompenses
    if action < 0:
        reward -= 0.5
    # La prochaine étape vers le Trésor , Donner la plus haute récompense +1
    if new_state == N_STATES - 1:
        reward += 1
    # Si vous marchez à gauche jusqu'à la fin , Encore à gauche , Obtenir une récompense négative minimale -1
    #En même temps, Pour définir un nouvel état encore ici ,Sinon, une erreur sera signalée
    if new_state < 0:
        new_state = 0
        reward -= 1
    return new_state, reward


def update_env(state, epoch, step):
    env_list = ['-'] * (N_STATES - 1) + ['T']
    if state == N_STATES - 1:
        # Atteindre la destination
        print("")
        print("epoch=" + str(epoch) + ", step=" + str(step), end='')
        time.sleep(2)
    else:
        env_list[state] = '#'
        print('\r' + ''.join(env_list), end='')
        time.sleep(fresh_time)


def q_learning():
    for epoch in range(max_episodes):
        step = 0  # Déplacer les étapes
        state = 0  # État initial
        update_env(state, epoch, step)
        while state != N_STATES - 1:
            cur_action = choose_action(state, q_table)
            new_state, reward = get_env_feedback(state, cur_action)
            q_pred = q_table.loc[state, cur_action]
            if new_state != N_STATES - 1:
                q_target = reward + gamma * q_table.loc[new_state, :].max()
            else:
                q_target = reward
            q_table.loc[state, cur_action] += alpha * (q_target - q_pred)
            state = new_state
            update_env(state, epoch, step)
            step += 1
    return q_table


q_learning()

2.、Saras

  Saras C'est aussi l'algorithme le plus fondamental dans l'apprentissage intensif ,Mais aussi avecQStockage des tablesQ(s,a), C'est pour ça que Saras,C'est à cause d'untransitionContient(s,a,r,a,s)Quintuple,C'est - à - dire:Saras.

1. Value-based
2. On-Policy
     Comparer iciQ-learning, On saura que , Les données utilisées ici sont actuelles policyProduit,Et mise à jourQQuand ça en vaut la peine., Est basé sur de nouvelles actions et de nouveaux états QValeur, De nouvelles actions seront exécutées （ Notez qu'il n'y a pas de max）,Alors c'estOn-Policy.
3. Pseudo - Code
   
4. Réalisation
     Voir iciQ-learning Avec des modifications simples , C'est basé sur le nouvel état , Ré - sélectionner une action , Et pour le faire ,Mise à jourQQuand ça en vaut la peine., Directement basé sur l'état correspondant à l'action QMise à jour de la valeur.

import numpy as np
import pandas as pd
import time

N_STATES = 6  # 6Statut,Longueur du tableau unidimensionnel
ACTIONS = [-1, 1]  # Deux états,-1：left, 1:right
epsilon = 0.9  # greedy
alpha = 0.1  # Taux d'apprentissage
gamma = 0.9  # Valeur décroissante de la récompense
max_episodes = 10  #  Nombre maximum de Tours 
fresh_time = 0.3  #  Intervalle de déplacement 

# q_table
#Générer(N_STATES,len(ACTIONS)))DeQ Valeur vide Tableau 
q_table = pd.DataFrame(np.zeros((N_STATES, len(ACTIONS))), columns=ACTIONS)


# choose action: 
#0.9 Probabilité de cupidité ,0.1 Action aléatoire probabiliste , Maintenir une certaine exploration 
def choose_action(state, table):
    state_actions = table.iloc[state, :]
    if np.random.uniform() > epsilon or state_actions.all() == 0:
        action = np.random.choice(ACTIONS)
    else:
        action = state_actions.argmax()
    return action


def get_env_feedback(state, action):
	#Nouveau statut = État actuel + État du Mouvement
    new_state = state + action
    reward = 0
    # Déplacer à droite plus 0.5
    #À droite., Plus près du Trésor ,Obtenir+0.5Récompenses
    if action > 0:
        reward += 0.5
    #À gauche., Loin du Trésor ,Obtenir-0.5Récompenses
    if action < 0:
        reward -= 0.5
    # La prochaine étape vers le Trésor , Donner la plus haute récompense +1
    if new_state == N_STATES - 1:
        reward += 1
    # Si vous marchez à gauche jusqu'à la fin , Encore à gauche , Obtenir une récompense négative minimale -1
    #En même temps, Pour définir un nouvel état encore ici ,Sinon, une erreur sera signalée
    if new_state < 0:
        new_state = 0
        reward -= 1
    return new_state, reward

# Maintenir l'environnement 
def update_env(state, epoch, step):
    env_list = ['-'] * (N_STATES - 1) + ['T']
    if state == N_STATES - 1:
        # Atteindre la destination
        print("")
        print("epoch=" + str(epoch) + ", step=" + str(step), end='')
        time.sleep(2)
    else:
        env_list[state] = '#'
        print('\r' + ''.join(env_list), end='')
        time.sleep(fresh_time)

#Mise à jourQTableau
def Saras():
    for epoch in range(max_episodes):
        step = 0  # Déplacer les étapes
        state = 0  # État initial
        update_env(state, epoch, step)
        cur_action = choose_action(state, q_table)

        while state != N_STATES - 1:
            new_state, reward = get_env_feedback(state, cur_action)
            new_action = choose_action(new_state,q_table)
            q_pred = q_table.loc[state, cur_action]
            if new_state != N_STATES - 1:
                q_target = reward + gamma * q_table.loc[new_state, new_action]
            else:
                q_target = reward
            q_table.loc[state, cur_action] += alpha * (q_target - q_pred)
            state,cur_action = new_state,new_action
            update_env(state, epoch, step)
            step += 1

    return q_table


Saras()

  Bloguer pour la première fois, Peut comprendre qu'il y a un problème , J'espère corriger l'erreur .