Q-Learning的学习及简单应用

       强化学习（Reinforcement Learning）是一种机器学习算法，强调如何基于环境而行动，以取得最大化的预期利益，在机器人领域应用较为广泛。Q-Learning属于强化学习的经典算法，用于解决马尔可夫决策问题。

马尔可夫决策过程（Markov Decision Processes,MDP）

       强化学习研究的问题都是基于马尔可夫决策过程的，分为有限马尔可夫决策过程和无限马尔可夫决策过程。这里主要介绍有限马尔可夫决策过程。

       马尔可夫性质：根据每个时刻观察到的状态，从可用的行动集合中选用一个行动作出决策，系统下一步（未来）的状态是随机的，并且其下一步状态与历史状态无关。

       马尔可夫决策过程可以描述为：一个机器人（agent）通过采取行动（action）改变自身状态（state），与环境（E）互动得到回报（Reward）。目的是通过一定的行动策略（π）获得最大回报。它有5个元素构成：

              S：所有可能的状态的集合（元素可能会很多，设计的时候需要合并或舍弃）

              A：在状态S下可以做出的行为

              p：Pa(S, S')，表示在a行为下t时刻状态S转化为t+1时刻状态S'的概率

              Gamma：衰减变量，距离当前时刻t越远的回报R对当前决策的影响越小，避免在无限时间序列中导致的无偏向问题

              V：衡量策略（π）的价值，与当前立即回报以及未来预期回报有关，v(S) = E [U|St]，U = R(t+1)+Gamma*R(t+2)+Gamma^2*R(t+3)...，其中R(t+n)表示在t+n时刻的回报

一个例子：k-armed bandit

        假设有一台赌博机，一共有k个扳手，按下每个扳手的得奖概率不相同。如何用最少的次数，确定回报最大的扳手并得到最多奖励？

        一个最简单的思路是每个扳手试验1000次，估算出获奖概率。大量的重复实验可以较为准确地获得接近真实的概率，但效率显然不是最高。

        还有一种思路是先每个试验10次，并在之后一直坚持估算概率最高的扳手（Greedy算法），效率提高但所选的扳手可能不是得奖概率最高的。

        改进：选择一个比较小的数 ε（如0.1），然后生成一个0~1之间的随机小数，如果该数小于 ε，则随机挑一个目前看来得奖概率不高的扳手，反之，继续坚持目前概率最高的扳手。该算法称为 ε-greedy算法（关于这些算法性能的比较见下图）

        另外的思路：UCB算法（Upper Confidence Bound）。对一个扳手的评估：value+sqrt((2 *total_counts) /  counts)，value是当前得奖概率，sqr((2 *total_counts) / counts)是对这个扳手的了解程度，total_counts总实验次数，counts是对这个扳手的试验次数。在所有的评估中选最大值进行下一次试验。可以看出，如果一个扳手试验次数比较少，则有很高的概率在下一次被选中。该算法避免随机数，每个值都是可以直接计算出来的，可以让没有机会尝试的扳手得到更多的机会。

       各算法的效率如图：

       

       

       （来源：Reinforcement Learning - An Introduction，CHAPTER 2. MULTI-ARM BANDITS）

       以上算法的思想是在exploration和exploitation之间的折衷，在马尔可夫问题中，不可能立刻找到最优的策略，但如何快速收敛是考察问题的重点。

        

马尔可夫问题求解

        主要思想有3类：动态规划（不适用于大型问题），蒙特卡洛方法， Temporal-Difference Learning。其中蒙特卡洛方法与蒙特卡洛搜索树在原理上有相似性，容易被混淆。

        Q-Learning属于Temporal-Difference Learning的一种，思想如下：

       

        （来源：Reinforcement Learning - An Introduction，CHAPTER 6. TEMPORAL-DIFFERENCE LEARNING）

        

          其中α是学习率，一般取（0，1）之间的数，学习率越大，收敛速度越快，但可能会导致过拟合问题。Q（S，A）指在状态S下执行A的质量（越大越好）

        

使用Q-Learning挑战robocode

        Robocode 是 IBM 开发的 Java 战斗机器人平台，游戏者可以在平台上设计一个 Java 坦克。每个坦克有个从战场上收集信息的感应器，并且它们还有一个执行动作的传动器。其规则和原理类似于现实中的坦克战斗。（介绍参见http://robocode.sourceforge.net/）

       设计思路：

       1. 选择States：一共有5个状态分类：当前坦克方位，距离敌方坦克距离，与敌方坦克相对夹角，是否撞墙，是否被击中。其中当前坦克方位每90°算一个状态，距离敌方坦克距离有20个状态（0，100000），与敌方坦克相对夹角有16个状态便于微调，是否撞墙和是否被击中各有两个状态。

       2. 选择action：一共6个动作：前进300步；后退300步；左转20°并前进300步；右转20°并前进300步；左转20°并后退300步；右转20°并后退300步

       3. Gamma值：0.1

       4. 选择ε-greedy算法进行exploration和exploitation的折衷

       5. 评分：每射出一个子弹扣分：e.getBullet().getPower()；

                      被子弹击中扣分：e.getBullet().getPower()；

                      撞墙扣分：(Math.abs(getVelocity()) * 0.5 - 1)；

                      撞到敌方坦克扣分：6；

                      击中敌方坦克加分：e.getBullet().getPower() * 9；

       设计简化了坦克炮管的校准和雷达的探测，所以结果不尽如人意，需要继续调整。部分代码如下：

        

        QLRobot负责收集敌方坦克信息控制坦克行动，并对行动结果评分

package robot;

import java.awt.*;
import java.awt.geom.*;
import robocode.*;
import robocode.AdvancedRobot;

public class QLRobot extends AdvancedRobot {
    //Q值存储表
    private QLTable table;
    //在状态state下采取action行为获得的回报
    private double reward = 0.0;
    //火力值(0,3]
    private double firePower;
    //方向
    private int direction = 1;
    //是否撞墙
    private int isHitWall = 0;
    //是否被击中
    private int isHitByBullet = 0;
    //存取数据
    private Data data = new Data();
    //敌方状态
    private double distance = 100000;
    private long ctime;
    private double targetX;
    private double targetY;
    private double bearing;
    private double turnDegree = 20.0;
    private double moveDistance = 100.0;

    public void run() {
        table = data.readData();

        setAdjustGunForRobotTurn(true);
        setAdjustRadarForGunTurn(true);
        turnRadarRightRadians(2 * Math.PI);

        while (true) {
            robotMovement();
            firePower = 50 / distance;
            if (firePower > 3)
                firePower = 3;
            //radarMovement();
            if (getGunHeat() == 0) {
                setFire(firePower);
            }
            execute();
        }
    }

    void doMovement() {
        if (getTime() % 20 == 0) {
            direction *= -1;
            setAhead(direction * 300);
        }
        setTurnRightRadians(bearing + (Math.PI / 2));
    }

    private void robotMovement() {
        int state = getState();
        int action = table.selectAction(state);

        table.learn(state, action, reward);
        reward = 0.0;
        isHitWall = 0;
        isHitByBullet = 0;

        switch (action) {
            case 0:
                setAhead(moveDistance);
                break;
            case 1:
                setBack(moveDistance);
                break;
            case 2:
                setAhead(moveDistance);
                setTurnLeft(turnDegree);
                break;
            case 3:
                setAhead(moveDistance);
                setTurnRight(turnDegree);
                break;
            case 4:
                setAhead(moveDistance);
                setTurnLeft(turnDegree);
                break;
            case 5:
                setBack(moveDistance);
                setTurnLeft(turnDegree);
                break;
            case 6:
                setBack(moveDistance);
                setTurnRight(turnDegree);
                break;
        }
    }

    private int getState() {
        int heading = State.getHeading(getHeading());
        int targetDistance = State.getTargetDistance(distance);
        int targetBearing = State.getTargetBearing(bearing);
        int state = State.Mapping[heading][targetDistance][targetBearing][isHitWall][isHitByBullet];
        return state;
    }

    private void radarMovement() {
        double radarOffset;
        if (getTime() - ctime > 4) {
            radarOffset = 4 * Math.PI;
        } else {
            radarOffset = getRadarHeadingRadians() - (Math.PI / 2 - Math.atan2(targetY - getY(), targetX - getX()));
            radarOffset = NormaliseBearing(radarOffset);
            if (radarOffset < 0)
                radarOffset -= Math.PI / 10;
            else
                radarOffset += Math.PI / 10;
        }
        setTurnRadarLeftRadians(radarOffset);
    }

    double NormaliseBearing(double ang) {
        if (ang > Math.PI)
            ang -= 2 * Math.PI;
        if (ang < -Math.PI)
            ang += 2 * Math.PI;
        return ang;
    }

    double NormaliseHeading(double ang) {
        if (ang > 2 * Math.PI)
            ang -= 2 * Math.PI;
        if (ang < 0)
            ang += 2 * Math.PI;
        return ang;
    }

    public void onBulletHit(BulletHitEvent e) {
        double change = e.getBullet().getPower() * 9;
        reward += change;
    }

    public void onBulletMissed(BulletMissedEvent e) {
        double change = -e.getBullet().getPower();
        reward += change;
    }

    public void onHitByBullet(HitByBulletEvent e) {
        double power = e.getBullet().getPower();
        double change = -(4 * power + 2 * (power - 1));
        reward += change;
        isHitByBullet = 1;
    }

    public void onHitRobot(HitRobotEvent e) {
        reward += -6.0;
    }

    public void onHitWall(HitWallEvent e) {
        double change = -(Math.abs(getVelocity()) * 0.5 - 1);
        reward += change;
        isHitWall = 1;
    }

    public void onScannedRobot(ScannedRobotEvent e) {
        if (e.getDistance() < distance) {
            //找到敌人方位
            double absbearing = (getHeadingRadians() + e.getBearingRadians()) % (2 * Math.PI);
            //旋转到该方位
            setTurnLeft(absbearing);
            targetX = getX() + Math.sin(absbearing) * e.getDistance();
            targetY = getY() + Math.cos(absbearing) * e.getDistance();

            bearing = e.getBearingRadians();
            ctime = getTime();
            distance = e.getDistance();
        }
    }

    public void onWin(WinEvent event) {
        data.saveData(table);
    }

    public void onDeath(DeathEvent event) {
        data.saveData(table);
    }
}

          QLTable负责记录并学习更新Q值，是Q-Learning实现的主要部分

package robot;

import java.io.Serializable;

public class QLTable implements Serializable{
    private double[][] table;
    //状态数
    private final int states = 4 * 20 * 16 * 2 * 2;
    //行为数
    private final int actions = 7;
    //是否是第一次行动
    private boolean first = true;
    //保存上一次状态
    private int lastState;
    //保存上一次行为
    private int lastAction;
    //衰减变量
    private double gamma = 0.8;
    //学习率
    private double e = 0.1;
    //探索值
    private double exploration = 0.2;

    public QLTable() {
        table = new double[states][actions];
        for (int i = 0; i < states; i++)
            for (int j = 0; j < actions; j++)
                table[i][j] = 0;
    }

    //对上个状态采取的action进行反馈
    public void learn(int state, int action, double reward) {
        if (first)
            first = false;
        else {
            double oldValue = table[lastState][lastAction];
            double newValue = (1 - e) * oldValue + e * (reward + gamma * getMaxValue(state));
            //更新Q值
            table[lastState][lastAction] = newValue;
        }
        lastState = state;
        lastAction = action;
    }

    //获得某个state的最大Q值
    private double getMaxValue(int state) {
        double max = table[state][0];
        for (int i = 0; i < actions; i++) {
            if (table[state][i] > max)
                max = table[state][i];
        }
        return max;
    }

    //根据目前的state，选择最合适的action
    public int selectAction(int state) {
        double qValue;
        double sum = 0.0;
        double[] value = new double[actions];
        for (int i = 0; i < value.length; i++) {
            qValue = table[state][i];
            //保证为正数，且不改变函数增减性
            value[i] = Math.exp(qValue);
            sum += value[i];
        }

        //计算P(a|s)
        if (sum != 0) {
            for (int i = 0; i < value.length; i++) {
                value[i] /= sum;
            }
        } else
            return getBestAction(state);

        int action = 0;
        double cumProb = 0.0;
        double randomNum = Math.random();
        //大于探索值进行探索
        if (randomNum < exploration) {
            //保证每一种action都探索到
            while (randomNum > cumProb && action < value.length) {
                cumProb += value[action];
                action++;
            }
            return action - 1;
        } else {
            //greedy
            return getBestAction(state);
        }
    }

    //获得最优action
    private int getBestAction(int state) {
        double max = table[state][0];
        int action = 0;

        for (int i = 0; i < actions; i++) {
            if (table[state][i] > max) {
                max = table[state][i];
                action = i;
            }
        }
        return action;
    }
}

         实战结果如下：

        

         

    

         结果分析：在训练次数较少的情况下（10次）结果并不理想，另外炮管和雷达的角度修正出现比较严重的偏差，需要继续调整。对于较大训练次数的情况有待于后续观察