NeuroWhAI의 잡블로그

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

개발 및 공부/알고리즘

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

NeuroWhAI 2018. 6. 2. 16:40 ...




Q Learning은 DQN의 뼈대가 되는 학습 방법입니다.
저는 공부 순서가 반대로 되어버렸지만 Q Learning을 알고 DQN을 공부했다면 더 쉽게 가지 않았을까.. 싶네요.

Q Learning으로 강화 학습의 Hello, World!라고 할 수 있는
Frozen Lake 게임을 학습시켜 보았습니다.

아래 코드에서 대부분은 Frozen Lake 게임을 구현하는 코드(FrozenLake 클래스)나 출력 코드이고
중요한 학습은 QLearner 클래스의 learn 메소드에서 이뤄집니다.

코드:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
#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(-10);
    }
    else if (action == Actions::Right)
    {
      return moveAgent(+10);
    }
    
    return { 0true };
  }
  
  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;
}
cs

결과:




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

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




0 Comments
댓글쓰기 폼