Processus de décision de Markov: itération de la valeur, comment ça marche?

Question

J'ai lu beaucoup de choses sur Processus de décision de Markov (en utilisant l'itération de valeur) récemment, mais je n'arrive tout simplement pas à comprendre. J'ai trouvé beaucoup de ressources sur Internet/livres, mais elles utilisent toutes des formules mathématiques beaucoup trop complexes pour mes compétences.

Comme c'est ma première année à l'université, j'ai trouvé que les explications et les formules fournies sur le Web utilisent des notions/termes beaucoup trop compliqués pour moi et ils supposent que le lecteur sait certaines choses dont je n'ai tout simplement jamais entendu parler .

Je veux l'utiliser sur une grille 2D (remplie de murs (inaccessibles), de pièces (souhaitables) et d'ennemis qui bougent (ce qui doit être évité à tout prix)). L'objectif est de collecter toutes les pièces sans toucher les ennemis, et je veux créer une IA pour le joueur principal en utilisant un processus de décision de Markov ( [~ # ~] mdp [~ # ~ ] ). Voici à quoi cela ressemble partiellement (notez que l'aspect lié au jeu n'est pas tellement un problème ici. Je veux vraiment comprendre les MDP dans général):

D'après ce que je comprends, une simplification grossière des MDP est qu'ils peuvent créer une grille qui tient dans quelle direction nous devons aller (une sorte de grille de "flèches" pointant où nous devons aller, en commençant à une certaine position sur la grille) pour atteindre certains objectifs et éviter certains obstacles. Spécifique à ma situation, cela signifierait que cela permet au joueur de savoir dans quelle direction aller pour récupérer les pièces et éviter les ennemis.

Maintenant, en utilisant les termes [~ # ~] mdp [~ # ~] , cela signifierait qu'il crée une collection d'états (la grille) qui détient certaines politiques (l'action à prendre -> haut, bas, droite, gauche) pour un certain état (une position sur la grille). Les politiques sont déterminées par les valeurs d '"utilité" de chaque État, qui sont elles-mêmes calculées en évaluant combien il serait bénéfique d'y arriver à court et à long terme.

Est-ce correct? Ou suis-je complètement sur la mauvaise voie?

J'aimerais au moins savoir ce que les variables de l'équation suivante représentent dans ma situation:

(extrait du livre "Intelligence artificielle - Une approche moderne" de Russell & Norvig)

Je sais que s serait une liste de tous les carrés de la grille, a serait une action spécifique (haut/bas/droite/gauche), mais qu'en est-il du reste?

Comment les fonctions de récompense et d'utilité seraient-elles mises en œuvre?

Ce serait vraiment génial si quelqu'un connaissait un lien simple qui montre un pseudo-code pour implémenter une version de base avec des similitudes avec ma situation de manière très lente, car je ne sais même pas par où commencer ici.

Merci pour votre précieux temps.

(Remarque: n'hésitez pas à ajouter/supprimer des balises ou à me dire dans les commentaires si je dois donner plus de détails sur quelque chose ou quelque chose comme ça.)

Answer 1

Oui, la notation mathématique peut la rendre beaucoup plus compliquée qu'elle ne l'est. Vraiment, c'est une idée très simple. J'ai implémenté une applet de démonstration d'itération de valeur avec laquelle vous pouvez jouer pour avoir une meilleure idée.

Fondamentalement, disons que vous avez une grille 2D avec un robot. Le robot peut essayer de se déplacer vers le nord, le sud, l'est, l'ouest (ce sont les actions a) mais, comme sa roue gauche est glissante, lorsqu'il essaie de se déplacer vers le nord, il y a seulement une probabilité de 9 pour qu'il se retrouve sur la place. Au nord de celui-ci alors qu'il y a une probabilité de 0,1 qu'il finisse au carré à l'ouest de celui-ci (de même pour les 3 autres actions). Ces probabilités sont capturées par la fonction T(). À savoir, T (s, A, s ') ressemblera à:

s    A      s'     T    //x=0,y=0 is at the top-left of the screen
x,y  North  x,y+1  .9   //we do move north
x,y  North  x-1,y  .1   //wheels slipped, so we move West
x,y  East   x+1,y  .9
x,y  East   x,y-1  .1
x,y  South  x,y+1  .9
x,y  South  x-1,y  .1 
x,y  West   x-1,y  .9
x,y  West   x,y+1  .1 

Vous définissez ensuite la récompense sur 0 pour tous les états, mais sur 100 pour l'état de l'objectif, c'est-à-dire l'emplacement où vous souhaitez que le robot se rende.

Ce que fait l'itération de valeur, c'est ses débuts en donnant un utilitaire de 100 à l'état de l'objectif et de 0 à tous les autres états. Ensuite, lors de la première itération, ces 100 utilitaires sont distribués en 1 étape à partir de l'objectif, de sorte que tous les états qui peuvent atteindre l'état de l'objectif en 1 étape (les 4 carrés juste à côté) obtiendront une certaine utilité. À savoir, ils obtiendront un utilitaire égal à la probabilité que de cet état nous puissions atteindre l'objectif déclaré. Nous continuons ensuite à répéter, à chaque étape, nous déplaçons l'utilitaire à 1 pas de plus du but.

Dans l'exemple ci-dessus, disons que vous commencez par R (5,5) = 100 et R(.) = 0 pour tous les autres états. Le but est donc d'arriver à 5,5.

Lors de la première itération, nous avons défini

R(5,6) = gamma * (.9 * 100) + gamma * (.1 * 100)

parce que sur 5,6 si vous allez vers le nord, il y a une probabilité de .9 de finir à 5,5, tandis que si vous allez vers l'ouest, il y a une probabilité de 0,1 pour finir à 5,5.

De même pour (5,4), (4,5), (6,5).

Tous les autres états restent avec U = 0 après la première itération d'itération de valeur.

Answer 2

Pas une réponse complète, mais une remarque clarifiante.

L'état est pas une seule cellule. L'état contient les informations contenues dans chaque cellule pour toutes les cellules concernées à la fois. Cela signifie qu'un élément d'état contient les informations sur les cellules solides et les cellules vides; lesquels contiennent des monstres; où sont les pièces; où est le joueur.

Vous pourriez peut-être utiliser une carte de chaque cellule à son contenu comme état. Cela ignore le mouvement des monstres et des joueurs, qui sont probablement très importants également.

Les détails dépendent de la façon dont vous souhaitez modéliser votre problème (décider ce qui appartient à l'État et sous quelle forme).

Ensuite, une politique mappe chaque état à une action comme gauche, droite, saut, etc.

Vous devez d'abord comprendre le problème exprimé par un MDP avant de réfléchir au fonctionnement d'algorithmes comme l'itération de valeur.

Answer 3

Je recommanderais d'utiliser Q-learning pour votre implémentation.

Vous pouvez peut-être utiliser ce post que j'ai écrit comme source d'inspiration. Ceci est une démo Q-learning avec Java . Cette démo est une carte avec 6 champs et l'IA apprend où elle doit aller de chaque état pour arriver à la récompense.

Le Q-learning est une technique permettant à l'IA d'apprendre par elle-même en lui accordant une récompense ou une punition.

Cet exemple montre le Q-learning utilisé pour la recherche de chemin. Un robot apprend où il doit aller de n'importe quel état.

Le robot démarre à un endroit aléatoire, il garde la mémoire du score pendant qu'il explore la zone, chaque fois qu'il atteint le but, nous répétons avec un nouveau départ aléatoire. Après suffisamment de répétitions, les valeurs de score seront stationnaires (convergence).

Dans cet exemple, le résultat de l'action est déterministe (la probabilité de transition est de 1) et la sélection de l'action est aléatoire. Les valeurs de score sont calculées par l'algorithme Q-learning Q (s, a).
L'image montre les états (A, B, C, D, E, F), les actions possibles des états et la récompense donnée.

Résultat Q * (s, a)

Politique Π * (s)

Qlearning.Java

import Java.text.DecimalFormat;
import Java.util.Random;

/**
 * @author Kunuk Nykjaer
 */
public class Qlearning {
    final DecimalFormat df = new DecimalFormat("#.##");

    // path finding
    final double alpha = 0.1;
    final double gamma = 0.9;


// states A,B,C,D,E,F
// e.g. from A we can go to B or D
// from C we can only go to C
// C is goal state, reward 100 when B->C or F->C
//
// _______
// |A|B|C|
// |_____|
// |D|E|F|
// |_____|
//

    final int stateA = 0;
    final int stateB = 1;
    final int stateC = 2;
    final int stateD = 3;
    final int stateE = 4;
    final int stateF = 5;

    final int statesCount = 6;
    final int[] states = new int[]{stateA,stateB,stateC,stateD,stateE,stateF};

    // http://en.wikipedia.org/wiki/Q-learning
    // http://people.revoledu.com/kardi/tutorial/ReinforcementLearning/Q-Learning.htm

    // Q(s,a)= Q(s,a) + alpha * (R(s,a) + gamma * Max(next state, all actions) - Q(s,a))

    int[][] R = new int[statesCount][statesCount]; // reward lookup
    double[][] Q = new double[statesCount][statesCount]; // Q learning

    int[] actionsFromA = new int[] { stateB, stateD };
    int[] actionsFromB = new int[] { stateA, stateC, stateE };
    int[] actionsFromC = new int[] { stateC };
    int[] actionsFromD = new int[] { stateA, stateE };
    int[] actionsFromE = new int[] { stateB, stateD, stateF };
    int[] actionsFromF = new int[] { stateC, stateE };
    int[][] actions = new int[][] { actionsFromA, actionsFromB, actionsFromC,
            actionsFromD, actionsFromE, actionsFromF };

    String[] stateNames = new String[] { "A", "B", "C", "D", "E", "F" };

    public Qlearning() {
        init();
    }

    public void init() {       
        R[stateB][stateC] = 100; // from b to c
        R[stateF][stateC] = 100; // from f to c    
    }

    public static void main(String[] args) {
        long BEGIN = System.currentTimeMillis();

        Qlearning obj = new Qlearning();

        obj.run();
        obj.printResult();
        obj.showPolicy();

        long END = System.currentTimeMillis();
        System.out.println("Time: " + (END - BEGIN) / 1000.0 + " sec.");
    }

    void run() {
        /*
         1. Set parameter , and environment reward matrix R
         2. Initialize matrix Q as zero matrix
         3. For each episode: Select random initial state
            Do while not reach goal state o
                Select one among all possible actions for the current state o
                Using this possible action, consider to go to the next state o
                Get maximum Q value of this next state based on all possible actions o
                Compute o Set the next state as the current state
         */

        // For each episode
        Random Rand = new Random();
        for (int i = 0; i < 1000; i++) { // train episodes
            // Select random initial state
            int state = Rand.nextInt(statesCount);
            while (state != stateC) // goal state
            {
                // Select one among all possible actions for the current state
                int[] actionsFromState = actions[state];

                // Selection strategy is random in this example
                int index = Rand.nextInt(actionsFromState.length);
                int action = actionsFromState[index];

                // Action outcome is set to deterministic in this example
                // Transition probability is 1
                int nextState = action; // data structure

                // Using this possible action, consider to go to the next state
                double q = Q(state, action);
                double maxQ = maxQ(nextState);
                int r = R(state, action);

                double value = q + alpha * (r + gamma * maxQ - q);
                setQ(state, action, value);

                // Set the next state as the current state
                state = nextState;
            }
        }
    }

    double maxQ(int s) {
        int[] actionsFromState = actions[s];
        double maxValue = Double.MIN_VALUE;
        for (int i = 0; i < actionsFromState.length; i++) {
            int nextState = actionsFromState[i];
            double value = Q[s][nextState];

            if (value > maxValue)
                maxValue = value;
        }
        return maxValue;
    }

    // get policy from state
    int policy(int state) {
        int[] actionsFromState = actions[state];
        double maxValue = Double.MIN_VALUE;
        int policyGotoState = state; // default goto self if not found
        for (int i = 0; i < actionsFromState.length; i++) {
            int nextState = actionsFromState[i];
            double value = Q[state][nextState];

            if (value > maxValue) {
                maxValue = value;
                policyGotoState = nextState;
            }
        }
        return policyGotoState;
    }

    double Q(int s, int a) {
        return Q[s][a];
    }

    void setQ(int s, int a, double value) {
        Q[s][a] = value;
    }

    int R(int s, int a) {
        return R[s][a];
    }

    void printResult() {
        System.out.println("Print result");
        for (int i = 0; i < Q.length; i++) {
            System.out.print("out from " + stateNames[i] + ":  ");
            for (int j = 0; j < Q[i].length; j++) {
                System.out.print(df.format(Q[i][j]) + " ");
            }
            System.out.println();
        }
    }

    // policy is maxQ(states)
    void showPolicy() {
        System.out.println("\nshowPolicy");
        for (int i = 0; i < states.length; i++) {
            int from = states[i];
            int to =  policy(from);
            System.out.println("from "+stateNames[from]+" goto "+stateNames[to]);
        }          
    }
}

Résultat d'impression

out from A:  0 90 0 72,9 0 0
out from B:  81 0 100 0 81 0
out from C:  0 0 0 0 0 0
out from D:  81 0 0 0 81 0
out from E:  0 90 0 72,9 0 90
out from F:  0 0 100 0 81 0

showPolicy
from a goto B
from b goto C
from c goto C
from d goto A
from e goto B
from f goto C
Time: 0.025 sec.

Answer 4

Je sais que c'est un article assez ancien, mais je l'ai rencontré lors de la recherche de questions liées au MDP, je voulais noter (pour les personnes qui viennent ici) quelques autres commentaires sur le moment où vous avez déclaré ce que "s" et "a" étaient .

Je pense que pour un vous avez tout à fait raison, c'est votre liste de [haut, bas, gauche, droite].

Cependant pour s c'est vraiment l'emplacement dans la grille et c'est l'endroit où vous pouvez aller. Cela signifie que vous choisissez un état, puis vous choisissez un s particulier et passez par toutes les actions qui peuvent vous amener à ce sprime, que vous utilisez pour comprendre ces valeurs. (choisissez un maximum parmi ceux-ci). Enfin, vous allez pour le prochain s 'et faites la même chose, lorsque vous avez épuisé toutes les valeurs du s, vous trouvez le maximum de ce que vous venez de terminer la recherche.

Supposons que vous ayez choisi une cellule de grille dans le coin, vous n'auriez que 2 états vers lesquels vous pourriez éventuellement vous déplacer (en supposant le coin inférieur gauche), selon la façon dont vous choisissez de "nommer" vos états, nous pourrions dans ce cas supposer qu'un état est une coordonnée x, y, donc votre état actuel s est 1,1 et votre liste s (ou s prime) est x + 1, y et x, y + 1 (pas de diagonale dans cet exemple) (La partie Summation qui va sur tous s ')

De plus, vous ne l'avez pas répertorié dans votre équation, mais le max est de a ou l'action qui vous donne le max, donc d'abord vous choisissez le s qui vous donne le max et ensuite à l'intérieur de celui-ci vous choisissez l'action (au moins c'est ma compréhension de l'algorithme).

Donc si tu avais

x,y+1 left = 10 
x,y+1 right = 5 

x+1,y left = 3
x+1,y right 2

Vous choisirez x, y + 1 comme votre s ', mais vous devrez ensuite choisir une action maximisée qui est dans ce cas laissée pour x, y + 1. Je ne sais pas s'il y a une différence subtile entre simplement trouver le nombre maximum et trouver l'état, alors le nombre maximum, alors peut-être que quelqu'un pourra un jour clarifier cela pour moi.

Si vos mouvements sont déterministes (ce qui signifie que si vous dites aller de l'avant, vous allez de l'avant avec 100% de certitude), alors c'est assez facile que vous ayez une action, mais s'ils ne sont pas déterministes, vous avez une certitude de 80%, alors vous devriez considérer le d'autres actions qui pourraient vous y amener. C'est le contexte de la roue glissante que Jose a mentionné ci-dessus.

Je ne veux pas nuire à ce que les autres ont dit, mais simplement donner des informations supplémentaires.