[C++] Q-Learning : Frozen Lake 코드

Q 러닝 설명 : https://ko.wikipedia.org/wiki/Q_%EB%9F%AC%EB%8B%9D

Q Learning은 DQN의 뼈대가 되는 학습 방법입니다.

저는 공부 순서가 반대로 되어버렸지만 Q Learning을 알고 DQN을 공부했다면 더 쉽게 가지 않았을까.. 싶네요.

Q Learning으로 강화 학습의 Hello, World!라고 할 수 있는

Frozen Lake 게임을 학습시켜 보았습니다.

아래 코드에서 대부분은 Frozen Lake 게임을 구현하는 코드(FrozenLake 클래스)나 출력 코드이고

중요한 학습은 QLearner 클래스의 learn 메소드에서 이뤄집니다.

코드:

#include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
 
 
 
 
using namespace std;
 
 
enum class Actions
{
  Up,
  Down,
  Left,
  Right
};
 
 
/*
https://gym.openai.com/envs/FrozenLake-v0
*/
class FrozenLake
{
public:
  struct Result
  {
    int reward;
    bool done;
  };
  
public:
  FrozenLake()
    : m_board{
      "SFFF",
      "FHFH",
      "FFFH",
      "HFFG"
    }
    , m_agentX(0), m_agentY(0)
  {
    
  }
  
private:
  char m_board[4][4+1];
  int m_agentX, m_agentY;
  
public:
  Result step(Actions action)
  {
    if (action == Actions::Up)
    {
      return moveAgent(0, -1);
    }
    else if (action == Actions::Down)
    {
      return moveAgent(0, +1);
    }
    else if (action == Actions::Left)
    {
      return moveAgent(-1, 0);
    }
    else if (action == Actions::Right)
    {
      return moveAgent(+1, 0);
    }
    
    return { 0, true };
  }
  
  void reset()
  {
    m_agentX = 0;
    m_agentY = 0;
  }
  
  void print() const
  {
    for (int y=0; y<4; ++y)
    {
      for (int x=0; x<4; ++x)
      {
        if (m_agentX == x && m_agentY == y)
        {
          cout.put('@');
        }
        else
        {
          cout.put(m_board[y][x]);
        }
      }
      
      cout << endl;
    }
  }
  
  int getAgentX() const
  {
    return m_agentX;
  }
  
  int getAgentY() const
  {
    return m_agentY;
  }
  
private:
  Result moveAgent(int x, int y)
  {
    Result result;
    result.reward = 0;
    result.done = false;
    
    
    m_agentX += x;
    m_agentY += y;
    
    if (m_agentX < 0)
    {
      m_agentX = 0;
      result.reward = -1;
    }
    else if (m_agentX >= 4)
    {
      m_agentX = 4 - 1;
      result.reward = -1;
    }
    
    if (m_agentY < 0)
    {
      m_agentY = 0;
      result.reward = -1;
    }
    else if (m_agentY >= 4)
    {
      m_agentY = 4 - 1;
      result.reward = -1;
    }
    
    
    if (m_board[m_agentY][m_agentX] == 'H')
    {
      result.reward = -1;
      result.done = true;
    }
    else if (m_board[m_agentY][m_agentX] == 'G')
    {
      result.reward = 10;
      result.done = true;
    }
    
    return result;
  }
};
 
 
class QLearner
{
public:
  QLearner()
    : m_scoreMap{ 0, }
  {
    
  }
  
private:
  // m_scoreMap[y][x][dir(up, down, left, right)] == (x, y)에서 dir로 이동했을 때의 점수
  int m_scoreMap[4][4][4];
  
public:
  void learn(FrozenLake& game, int totalEpochs)
  {
    const Actions actionList[4] = {
      Actions::Up,
      Actions::Down,
      Actions::Left,
      Actions::Right
    };
    
    for (int epoch = 1; epoch <= totalEpochs; ++epoch)
    {
      game.reset();
      
      for (int step = 1; step <= 100; ++step)
      {
        int actionIndex = rand() % 4;
 
        int oldX = game.getAgentX();
        int oldY = game.getAgentY();
 
        auto result = game.step(actionList[actionIndex]);
 
        int agentX = game.getAgentX();
        int agentY = game.getAgentY();
 
        int maxQ = *std::max_element(m_scoreMap[agentY][agentX], m_scoreMap[agentY][agentX] + 4);
 
        m_scoreMap[oldY][oldX][actionIndex] = result.reward + maxQ - 1;
 
        if (result.done)
        {
          break;
        }
      }
    }
  }
  
  void play(FrozenLake& game) const
  {
    const std::string actionName[] = {
      "Up", "Down", "Left", "Right"
    };
    
    game.reset();
    
    for (int step = 1; step <= 100; ++step)
    {
      int agentX = game.getAgentX();
      int agentY = game.getAgentY();
 
      int actionIndex = std::distance(m_scoreMap[agentY][agentX],
                                      std::max_element(m_scoreMap[agentY][agentX], m_scoreMap[agentY][agentX] + 4));
      
      cout << "Action " << actionName[actionIndex] << " Score " << m_scoreMap[agentY][agentX][actionIndex] << endl;
      
      auto result = game.step(static_cast<Actions>(actionIndex));
 
      game.print();
      
      cout << "----" << endl;
      
      if (result.done)
      {
        break;
      }
    }
    
    cout << "End!" << endl;
  }
  
  void print() const
  {
    for (int y=0; y<4; ++y)
    {
      for (int i=0; i<3; ++i)
      {
        for (int x=0; x<4; ++x)
        {
          if (i == 0)
          {
            cout << "    ";
            cout << setfill(' ') << setw(4) << m_scoreMap[y][x][0];
            cout << "    |";
          }
          else if (i == 1)
          {
            cout << setfill(' ') << setw(4) << m_scoreMap[y][x][2];
            cout << "    ";
            cout << setfill(' ') << setw(4) << m_scoreMap[y][x][3];
            cout << "|";
          }
          else
          {
            cout << "    ";
            cout << setfill(' ') << setw(4) << m_scoreMap[y][x][1];
            cout << "    |";
          }
        }
          
        cout << endl;
      }
        
      cout << std::string((4 * 3 + 1) * 4, '-') << endl;
    }
  }
};
 
 
int main()
{
  FrozenLake game;
  QLearner agent;
  
  agent.learn(game, 1000);
  
  agent.print();
  
  agent.play(game);
  
  
  return 0;
}

결과:

음... 사실 정석과는 좀 다른 공식이 되어버렸지만 뭐 클리어는 하니까 됬습니다(?)

할짓 없을때 유튜브에 있는 강화학습 강의를 보고 있는데 요즘 코딩을 너무 안한거 같아서 복습겸 했습니다.
그나저나 그렇게 자유자재(?)로 다루던 C++도 요즘 C#, Python, JS, Rust 한다고 안하니까 까먹기 시작하네요.
Actions::Up을 Actions.Up이라고 적는다거나 ㅋㅋ..
주력 언어인데 ㅠㅠ...