├── images
    ├── A2C.png
    ├── Reinforce.png
    └── Actor-Critic.png
├── README.md
├── model.py
├── 3-A2C.py
├── 3.A2C-multiple_action.ipynb
└── 2.Actor-Critic.ipynb


/images/A2C.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HiPatil/Policy-based-RL/HEAD/images/A2C.png


--------------------------------------------------------------------------------
/images/Reinforce.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HiPatil/Policy-based-RL/HEAD/images/Reinforce.png


--------------------------------------------------------------------------------
/images/Actor-Critic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HiPatil/Policy-based-RL/HEAD/images/Actor-Critic.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Policy Based RL
 2 | 
 3 | ### Algorithms Implemented
 4 | - [x] REINFORCE
 5 | - [x] Actor-Critic
 6 | - [x] Advantage Actor-Critic (A2C)
 7 | - [ ] Asynchronous Advantage Actor-Critic (A3C)
 8 | 
 9 | ### Comparison
10 | ##### Reinforce 
11 | ![](https://github.com/HiPatil/Policy-based-RL/blob/master/images/Reinforce.png)
12 | 
13 | ##### Actor-Critic
14 | ![](https://github.com/HiPatil/Policy-based-RL/blob/master/images/Actor-Critic.png)
15 | 
16 | ##### A2C
17 | ![](https://github.com/HiPatil/Policy-based-RL/blob/master/images/A2C.png)
18 | 


--------------------------------------------------------------------------------
/model.py:
--------------------------------------------------------------------------------
 1 | import tensorflow as tf
 2 | import tensorflow.keras.layers as layers
 3 | from tensorflow.keras import optimizers, Model
 4 | import gym
 5 | import mujoco_py
 6 | import numpy as np
 7 | import tensorflow_probability as tfp
 8 | 
 9 | gpu_devices = tf.config.experimental.list_physical_devices('GPU')
10 | tf.config.experimental.set_memory_growth(gpu_devices[0], True)
11 | 
12 | 
13 | print(tf.config.list_physical_devices('GPU'))
14 | env = gym.make('InvertedPendulum-v2')
15 | # env.reset()
16 | # for _ in range(100):
17 | # 	env.render()
18 | # 	env.step(env.action_space.sample())
19 | # env.close()
20 | 
21 | N_ACT = env.action_space.shape[0]
22 | N_OBS = env.observation_space.shape[0]
23 | print(N_OBS, N_ACT)
24 | 
25 | class reinforce(Model):
26 | 	def __init__(self, obs, act):
27 | 		super(reinforce, self).__init__()
28 | 		
29 | 		self.l1 = layers.Dense(units = 32, activation = 'relu')
30 | 		self.l2 = layers.Dense(units = 16, activation = 'relu')
31 | 		self.l3 = layers.Dense(units = act, activation = None)
32 | 
33 | 	def call(self, x):
34 | 		layer1 = self.l1(x)
35 | 		layer2 = self.l2(layer1)
36 | 		mean = self.l3(layer2)
37 | 
38 | 		return mean
39 | 
40 | policy = reinforce(N_OBS, N_ACT)
41 | optimizer = optimizers.Adam(lr = 0.01)
42 | 
43 | def choose_action(state, std = 0.0):
44 | 	m = policy(tf.convert_to_tensor(np.expand_dims(state, axis = 0),  dtype=tf.float32))
45 | 	dist = tfp.distributions.Normal(loc = m, scale = std)
46 | 	action = dist.sample()
47 | 	log_prob = dist.log_prob(action)
48 | 
49 | 	return action, log_prob
50 | 
51 | 
52 | state = env.reset()
53 | action, log_prob = choose_action(state)
54 | print(action)
55 | 


--------------------------------------------------------------------------------
/3-A2C.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import time
  3 | import random
  4 | import gym
  5 | import torch
  6 | import torch.nn as nn
  7 | import torch.optim as optim
  8 | import torch.nn.functional as F
  9 | from torch.utils.tensorboard import SummaryWriter
 10 | 
 11 | 
 12 | env = gym.make('InvertedPendulum-v2')
 13 | 
 14 | # import mujoco_py
 15 | 
 16 | 
 17 | test_env = False
 18 | if test_env:
 19 | 	env.reset()
 20 | 	for _ in range(1000):
 21 | 		env.render()
 22 | 		env.step(env.action_space.sample()) 	# take random actions
 23 | 	env.close()
 24 | 
 25 | print('Observation Shape:', env.observation_space.shape, '\nAction Shape:', env.action_space)
 26 | 
 27 | 
 28 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 29 | print("Code is running on:", device)
 30 | 
 31 | ############ PARAMETERS ####################
 32 | 
 33 | N_OBS = env.observation_space.shape[0]
 34 | N_ACT = env.action_space.shape[0]
 35 | N_EPISODE = 1500
 36 | LEARNING_RATE = 0.001
 37 | DISCOUNT = 0.99
 38 | 
 39 | ############### Network for A2C ####################3
 40 | class ACNet(nn.Module):
 41 | 	def __init__(self, observations, actions):
 42 | 		super(ACNet, self).__init__()
 43 | 		self.actor = nn.Sequential(
 44 | 			nn.Linear(observations,  32),
 45 | 			nn.ReLU(),
 46 | 			nn.Linear(32, 16),
 47 | 			nn.ReLU()
 48 | 			)
 49 | 		self.mu = nn.Linear(16, actions)
 50 | 		self.sigma = nn.Linear(16, actions)
 51 | 		
 52 | 
 53 | 		self.critic = nn.Sequential(
 54 |             nn.Linear(observations, 64),
 55 |             nn.ReLU(),
 56 |             nn.Linear(64, 32),
 57 |             nn.ReLU(),
 58 |             nn.Linear(32, 1)
 59 |             )
 60 | 
 61 | 	def forward(self, x):
 62 | 		act = self.actor(x)
 63 | 		mean = self.mu(act)
 64 | 		std = F.softplus(self.sigma(act))
 65 | 		value = self.critic(x)
 66 | 		# value = self.value(crt)
 67 | 
 68 | 		return mean, std, value
 69 | 
 70 | ac_network = ACNet(N_OBS, N_ACT).to(device)
 71 | optimizer = optim.Adam(ac_network.parameters())
 72 | 
 73 | writer = SummaryWriter('run/using_tensorboard')
 74 | 
 75 | def choose_action(state):
 76 | 	mu, sigma, value = ac_network(state)
 77 | 	m = torch.distributions.Normal(mu, sigma)
 78 | 	action = m.sample()
 79 | 	log_prob = m.log_prob(action)
 80 | 	return action.detach().cpu().numpy(), log_prob, value
 81 | 
 82 | def compute_returns(next_state, rewards, done, discount = DISCOUNT):
 83 | 	next_state = torch.FloatTensor(next_state).to(device)
 84 | 	_, _, next_q_val = ac_network(next_state)
 85 | 	returns = []
 86 | 	for step in reversed(range(len(rewards))):
 87 | 		next_q_val = rewards[step] + discount*next_q_val*(1-done[step])
 88 | 		returns.append(next_q_val)
 89 | 	returns.reverse()
 90 | 	return returns
 91 | 
 92 | def ACupdate(log_probs, q_vals, values):
 93 | 	optimizer.zero_grad()
 94 | 	ac_loss = 0
 95 | 	advantage = q_vals - values
 96 | #     print(-(log_probs*advantage).sum())
 97 | 	actor_loss = -(log_probs*advantage.detach()).mean()
 98 | 	critic_loss = advantage.pow(2).mean()
 99 | 	
100 | 	ac_loss = actor_loss+critic_loss
101 | 	ac_loss.backward()
102 | 	
103 | 	optimizer.step()
104 | 
105 | 	return ac_loss.item()
106 | 
107 | for i in range(1, N_EPISODE+1):
108 | 	ep_rewards = []
109 | 	log_probs = []
110 | 	done_states = []
111 | 
112 | 	total_reward = 0
113 | 	done = False
114 | 	values = []
115 | 	state = env.reset()
116 | 	while not done:
117 | 		state = torch.FloatTensor(state).to(device)
118 | 		action, log_prob, value = choose_action(state)
119 | 
120 | 		next_state, reward, done, info = env.step(action)
121 | 
122 | 		done = torch.tensor([done], dtype = torch.float, device = device)
123 | 		ep_rewards.append(torch.tensor([reward], dtype = torch.float, device = device))
124 | 		log_probs.append(log_prob)
125 | 		done_states.append(done)
126 | 		values.append(value)
127 | 
128 | 		total_reward += reward
129 | 		state = next_state
130 | 
131 | 	q_vals = compute_returns(next_state, ep_rewards, done_states)
132 | 	q_vals = torch.stack(q_vals)
133 | 	values = torch.stack(values)
134 | 	log_probs = torch.stack(log_probs)
135 | 
136 | 	loss = ACupdate(log_probs, q_vals, values)
137 | 
138 | 	writer.add_scalar('Attr/Training loss', loss, i)
139 | 	writer.add_scalar('Attr/Episode reward', total_reward, i)
140 | 	print('Episode Trained:', i)
141 | 	
142 | 	if i%1000 == 0:
143 | 		torch.save(ac_network.state_dict(), 'Models/ACNet_'+str(i)+'.pth')
144 | 		print('Model Saved')
145 | 
146 | print('Done Training')
147 | 
148 | 


--------------------------------------------------------------------------------
/3.A2C-multiple_action.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Advantage Actor Critic (A2C)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "code",
 12 |    "execution_count": 1,
 13 |    "metadata": {},
 14 |    "outputs": [],
 15 |    "source": [
 16 |     "import numpy as np\n",
 17 |     "import time\n",
 18 |     "import random\n",
 19 |     "import gym\n",
 20 |     "\n",
 21 |     "import torch\n",
 22 |     "import torch.nn as nn\n",
 23 |     "import torch.optim as optim\n",
 24 |     "import torch.nn.functional as F\n",
 25 |     "\n",
 26 |     "import matplotlib.pyplot as plt\n",
 27 |     "\n",
 28 |     "from IPython.display import clear_output\n",
 29 |     "%matplotlib inline"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 2,
 35 |    "metadata": {},
 36 |    "outputs": [
 37 |     {
 38 |      "name": "stdout",
 39 |      "output_type": "stream",
 40 |      "text": [
 41 |       "Observation Shape: (8,) \n",
 42 |       "Action Shape: Box(2,)\n"
 43 |      ]
 44 |     },
 45 |     {
 46 |      "name": "stderr",
 47 |      "output_type": "stream",
 48 |      "text": [
 49 |       "/home/himanshu/anaconda3/envs/rl/lib/python3.7/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
 50 |       "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
 51 |      ]
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "env = gym.make('LunarLanderContinuous-v2')\n",
 56 |     "\n",
 57 |     "print('Observation Shape:', env.observation_space.shape, '\\nAction Shape:', env.action_space)\n",
 58 |     "# env.reset()\n",
 59 |     "# for _ in range(100):\n",
 60 |     "#     env.render()\n",
 61 |     "#     time.sleep(0.01)\n",
 62 |     "#     env.step(env.action_space.sample())   # take random actions  \n",
 63 |     "# env.close()"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "markdown",
 68 |    "metadata": {},
 69 |    "source": [
 70 |     "### Checking for cuda device"
 71 |    ]
 72 |   },
 73 |   {
 74 |    "cell_type": "code",
 75 |    "execution_count": 3,
 76 |    "metadata": {},
 77 |    "outputs": [
 78 |     {
 79 |      "name": "stdout",
 80 |      "output_type": "stream",
 81 |      "text": [
 82 |       "cuda\n"
 83 |      ]
 84 |     }
 85 |    ],
 86 |    "source": [
 87 |     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
 88 |     "print(device)"
 89 |    ]
 90 |   },
 91 |   {
 92 |    "cell_type": "markdown",
 93 |    "metadata": {},
 94 |    "source": [
 95 |     "### Initialization of Hyperparameters"
 96 |    ]
 97 |   },
 98 |   {
 99 |    "cell_type": "code",
100 |    "execution_count": 5,
101 |    "metadata": {},
102 |    "outputs": [],
103 |    "source": [
104 |     "LEARNING_RATE = 0.001\n",
105 |     "DISCOUNT = 0.99\n",
106 |     "EPS = 1\n",
107 |     "EPS_DECAY = 0.9999\n",
108 |     "END_EPS = 0.1\n",
109 |     "\n",
110 |     "N_EPISODE = 20000\n",
111 |     "\n",
112 |     "\n",
113 |     "# Dimensions of input and output of environment\n",
114 |     "obs_dim = env.observation_space.shape[0]\n",
115 |     "action_dim = env.action_space.shape[0]\n"
116 |    ]
117 |   },
118 |   {
119 |    "cell_type": "markdown",
120 |    "metadata": {},
121 |    "source": [
122 |     "### Actor Network"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 6,
128 |    "metadata": {},
129 |    "outputs": [],
130 |    "source": [
131 |     "class Actor(nn.Module):\n",
132 |     "    def __init__(self, observations, actions):\n",
133 |     "        super(Actor, self).__init__()\n",
134 |     "        self.actor = nn.Sequential(\n",
135 |     "            nn.Linear(observations, 32),\n",
136 |     "            nn.ReLU(),\n",
137 |     "            nn.Linear(32, 16),\n",
138 |     "            nn.ReLU()\n",
139 |     "        )\n",
140 |     "        self.l1 = nn.Linear(16, actions)\n",
141 |     "        self.l2 = nn.Linear(16, actions)\n",
142 |     "        \n",
143 |     "    def forward(self, x):\n",
144 |     "        x = self.actor(x)\n",
145 |     "        mean = self.l1(x)\n",
146 |     "        variance = F.softplus(self.l2(x))\n",
147 |     "        \n",
148 |     "        return mean, variance"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "code",
153 |    "execution_count": 7,
154 |    "metadata": {},
155 |    "outputs": [],
156 |    "source": [
157 |     "actor = Actor(obs_dim, action_dim).to(device)\n",
158 |     "optimizerA = optim.Adam(actor.parameters())"
159 |    ]
160 |   },
161 |   {
162 |    "cell_type": "markdown",
163 |    "metadata": {},
164 |    "source": [
165 |     "### Sampling of action from Normal Distribution"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 8,
171 |    "metadata": {},
172 |    "outputs": [],
173 |    "source": [
174 |     "def actors_action(state):\n",
175 |     "    \n",
176 |     "    mean, variance = actor(state)\n",
177 |     "    \n",
178 |     "    m = torch.distributions.Normal(mean, torch.sqrt(variance))\n",
179 |     "    action = m.sample()\n",
180 |     "    log_prob = m.log_prob(action).sum(-1).unsqueeze(-1)\n",
181 |     "#     print(\"Entropy\", m.entropy())\n",
182 |     "    \n",
183 |     "    return action.detach().cpu().numpy(), log_prob"
184 |    ]
185 |   },
186 |   {
187 |    "cell_type": "markdown",
188 |    "metadata": {},
189 |    "source": [
190 |     "### Critic Network"
191 |    ]
192 |   },
193 |   {
194 |    "cell_type": "code",
195 |    "execution_count": 9,
196 |    "metadata": {},
197 |    "outputs": [],
198 |    "source": [
199 |     "class Critic(nn.Module):\n",
200 |     "    def __init__(self, observations):\n",
201 |     "        super(Critic, self).__init__()\n",
202 |     "        self.network = nn.Sequential(\n",
203 |     "            nn.Linear(observations, 64),\n",
204 |     "            nn.ReLU(),\n",
205 |     "            nn.Linear(64, 32),\n",
206 |     "            nn.ReLU(),\n",
207 |     "            nn.Linear(32, 1)\n",
208 |     "        )\n",
209 |     "    \n",
210 |     "    def forward(self, x):\n",
211 |     "        return self.network(x)"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "code",
216 |    "execution_count": 10,
217 |    "metadata": {},
218 |    "outputs": [],
219 |    "source": [
220 |     "critic = Critic(obs_dim).to(device)\n",
221 |     "optimizerC = optim.Adam(critic.parameters())\n",
222 |     "criterionC = nn.MSELoss().to(device)"
223 |    ]
224 |   },
225 |   {
226 |    "cell_type": "markdown",
227 |    "metadata": {},
228 |    "source": [
229 |     "### Computing Q-Values"
230 |    ]
231 |   },
232 |   {
233 |    "cell_type": "code",
234 |    "execution_count": 11,
235 |    "metadata": {},
236 |    "outputs": [],
237 |    "source": [
238 |     "def compute_returns(next_state, rewards, done, discount = DISCOUNT):\n",
239 |     "#     q_val = critic(state)\n",
240 |     "\n",
241 |     "    next_state = torch.FloatTensor(next_state).to(device)\n",
242 |     "    next_q_val = critic(next_state)\n",
243 |     "    returns = []\n",
244 |     "    for step in reversed(range(len(rewards))):\n",
245 |     "\n",
246 |     "        next_q_val = rewards[step] + discount*next_q_val*(1-done[step])\n",
247 |     "        returns.append(next_q_val)\n",
248 |     "        \n",
249 |     "    returns.reverse()\n",
250 |     "    \n",
251 |     "    return returns\n",
252 |     "    "
253 |    ]
254 |   },
255 |   {
256 |    "cell_type": "markdown",
257 |    "metadata": {},
258 |    "source": [
259 |     "### Updating Actor based on Q-values by critic"
260 |    ]
261 |   },
262 |   {
263 |    "cell_type": "code",
264 |    "execution_count": 12,
265 |    "metadata": {},
266 |    "outputs": [],
267 |    "source": [
268 |     "def ACupdate(log_probs, q_vals, values):\n",
269 |     "    optimizerA.zero_grad()\n",
270 |     "    optimizerC.zero_grad()\n",
271 |     "    \n",
272 |     "    actor_loss = 0\n",
273 |     "    critic_loss = 0\n",
274 |     "    \n",
275 |     "    advantage = q_vals - values\n",
276 |     "#     print(-(log_probs*advantage).sum())\n",
277 |     "    actor_loss = -(log_probs*advantage.detach()).mean()\n",
278 |     "    \n",
279 |     "    critic_loss = advantage.pow(2).mean()\n",
280 |     "    \n",
281 |     "#     for itr in range(len(log_probs)):\n",
282 |     "#         log_prob = log_probs[itr]\n",
283 |     "#         retr = ret[itr]\n",
284 |     "#         value = values[itr]\n",
285 |     "        \n",
286 |     "#         actor_loss -= torch.sum(log_prob*retr)\n",
287 |     "# #         print('AL', actor_loss)\n",
288 |     "        \n",
289 |     "# #         print(criterionC(value, retr))\n",
290 |     "#         critic_loss += criterionC(value, retr.detach())\n",
291 |     "        \n",
292 |     "    actor_loss.backward()\n",
293 |     "    critic_loss.backward()\n",
294 |     "    \n",
295 |     "    optimizerA.step()\n",
296 |     "    optimizerC.step()\n",
297 |     "    \n",
298 |     "    return (actor_loss+critic_loss).item()"
299 |    ]
300 |   },
301 |   {
302 |    "cell_type": "code",
303 |    "execution_count": 13,
304 |    "metadata": {},
305 |    "outputs": [],
306 |    "source": [
307 |     "mean_avg = []\n",
308 |     "losses = []\n",
309 |     "def plot(n_rewards, loss):\n",
310 |     "    clear_output(True)\n",
311 |     "    plt.figure(figsize=(30,5))\n",
312 |     "    mean = np.mean(n_rewards[-20:])\n",
313 |     "    plt.subplot(131)\n",
314 |     "    mean_avg.append(mean)\n",
315 |     "    plt.title('Reward: %s' % (mean))\n",
316 |     "    plt.plot(n_rewards)\n",
317 |     "    plt.plot(mean_avg)\n",
318 |     "    loss = loss/1000\n",
319 |     "    losses.append(loss)\n",
320 |     "    plt.subplot(132)\n",
321 |     "    plt.title('loss %.2f' % loss)\n",
322 |     "    plt.plot(losses)\n",
323 |     "    plt.show()"
324 |    ]
325 |   },
326 |   {
327 |    "cell_type": "markdown",
328 |    "metadata": {},
329 |    "source": [
330 |     "### Training QAC"
331 |    ]
332 |   },
333 |   {
334 |    "cell_type": "code",
335 |    "execution_count": null,
336 |    "metadata": {
337 |     "scrolled": false
338 |    },
339 |    "outputs": [
340 |     {
341 |      "data": {
342 |       "image/png": "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\n",
343 |       "text/plain": [
344 |        "<Figure size 2160x360 with 2 Axes>"
345 |       ]
346 |      },
347 |      "metadata": {
348 |       "needs_background": "light"
349 |      },
350 |      "output_type": "display_data"
351 |     }
352 |    ],
353 |    "source": [
354 |     "n_rewards = []\n",
355 |     "c = 0\n",
356 |     "for i in range(1, N_EPISODE+1):\n",
357 |     "    ep_rewards = []\n",
358 |     "    log_probs = []\n",
359 |     "    done_states = []\n",
360 |     "#     returns = []\n",
361 |     "    total_reward = 0\n",
362 |     "    done = False\n",
363 |     "    values = []\n",
364 |     "    \n",
365 |     "    state = env.reset()\n",
366 |     "    ret = 0\n",
367 |     "    \n",
368 |     "    while not done:\n",
369 |     "        state = torch.FloatTensor(state).to(device)\n",
370 |     "        action, log_prob = actors_action(state)\n",
371 |     "#         print(state, action)\n",
372 |     "        value = critic(state)\n",
373 |     "        \n",
374 |     "        next_state, reward, done, _ = env.step(action)\n",
375 |     "        \n",
376 |     "        done = torch.tensor([done], dtype = torch.float, device = device)\n",
377 |     "        ep_rewards.append(torch.tensor([reward], dtype = torch.float, device = device))\n",
378 |     "        log_probs.append(log_prob)\n",
379 |     "        done_states.append(done)\n",
380 |     "        values.append(value)\n",
381 |     "\n",
382 |     "        total_reward += reward\n",
383 |     "        \n",
384 |     "#         ret = compute_returns(next_state, reward, done, ret)\n",
385 |     "#         if i%25 == 0:\n",
386 |     "#             env.render()\n",
387 |     "#             time.sleep(0.02)\n",
388 |     "        state = next_state\n",
389 |     "\n",
390 |     "    q_vals = compute_returns(next_state, ep_rewards, done_states)\n",
391 |     "    q_vals = torch.stack(q_vals)\n",
392 |     "    values = torch.stack(values)\n",
393 |     "    log_probs = torch.stack(log_probs)\n",
394 |     "\n",
395 |     "    \n",
396 |     "    loss = ACupdate(log_probs, q_vals, values)\n",
397 |     "    \n",
398 |     "    n_rewards.append(total_reward)\n",
399 |     "    plot(n_rewards, loss)\n",
400 |     "    \n",
401 |     "#     if np.mean(n_rewards[-20:]) == 1000:\n",
402 |     "#         torch.save(actor.state_dict(), 'adv-actor.pth')\n",
403 |     "#         torch.save(critic.state_dict(), 'adv-critic.pth')\n",
404 |     "        \n",
405 |     "#         c += 1\n",
406 |     "        \n",
407 |     "#         print(\"Model Saved\")"
408 |    ]
409 |   },
410 |   {
411 |    "cell_type": "code",
412 |    "execution_count": null,
413 |    "metadata": {},
414 |    "outputs": [],
415 |    "source": [
416 |     "state = env.reset()\n",
417 |     "\n",
418 |     "\n",
419 |     "total_reward = 0\n",
420 |     "done = False\n",
421 |     "\n",
422 |     "actor.load_state_dict(torch.load('/home/himanshu/RL/Policy-based-RL/adv-actor.pth'))\n",
423 |     "critic.load_state_dict(torch.load('/home/himanshu/RL/Policy-based-RL/adv-critic.pth'))\n",
424 |     "print(\"Model Loaded\")\n",
425 |     "actor.to(device)\n",
426 |     "critic.to(device)\n",
427 |     "\n",
428 |     "while not done:\n",
429 |     "    state = torch.FloatTensor(state).to(device)\n",
430 |     "    action, log_prob = actors_action(state)\n",
431 |     "    \n",
432 |     "    next_state, reward, done, _ = env.step(action)\n",
433 |     "    total_reward += reward\n",
434 |     "    \n",
435 |     "    env.render()\n",
436 |     "    time.sleep(0.01)\n",
437 |     "    \n",
438 |     "    state = next_state\n",
439 |     "    \n",
440 |     "print('Duration till which pole is balanced: ', total_reward)\n",
441 |     "\n",
442 |     "env.close()"
443 |    ]
444 |   },
445 |   {
446 |    "cell_type": "code",
447 |    "execution_count": null,
448 |    "metadata": {},
449 |    "outputs": [],
450 |    "source": []
451 |   }
452 |  ],
453 |  "metadata": {
454 |   "kernelspec": {
455 |    "display_name": "Python 3",
456 |    "language": "python",
457 |    "name": "python3"
458 |   },
459 |   "language_info": {
460 |    "codemirror_mode": {
461 |     "name": "ipython",
462 |     "version": 3
463 |    },
464 |    "file_extension": ".py",
465 |    "mimetype": "text/x-python",
466 |    "name": "python",
467 |    "nbconvert_exporter": "python",
468 |    "pygments_lexer": "ipython3",
469 |    "version": "3.7.7"
470 |   }
471 |  },
472 |  "nbformat": 4,
473 |  "nbformat_minor": 4
474 | }
475 | 


--------------------------------------------------------------------------------
/2.Actor-Critic.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Action Value Actor Critic (QAC)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "code",
 12 |    "execution_count": 1,
 13 |    "metadata": {},
 14 |    "outputs": [],
 15 |    "source": [
 16 |     "import numpy as np\n",
 17 |     "import time\n",
 18 |     "import random\n",
 19 |     "import gym\n",
 20 |     "\n",
 21 |     "import torch\n",
 22 |     "import torch.nn as nn\n",
 23 |     "import torch.optim as optim\n",
 24 |     "import torch.nn.functional as F\n",
 25 |     "\n",
 26 |     "import matplotlib.pyplot as plt\n",
 27 |     "\n",
 28 |     "from IPython.display import clear_output\n",
 29 |     "%matplotlib inline"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 2,
 35 |    "metadata": {},
 36 |    "outputs": [
 37 |     {
 38 |      "name": "stdout",
 39 |      "output_type": "stream",
 40 |      "text": [
 41 |       "Observation Shape: (4,) \n",
 42 |       "Action Shape: Box(1,)\n"
 43 |      ]
 44 |     }
 45 |    ],
 46 |    "source": [
 47 |     "env = gym.make('InvertedPendulum-v2')\n",
 48 |     "\n",
 49 |     "print('Observation Shape:', env.observation_space.shape, '\\nAction Shape:', env.action_space)\n",
 50 |     "# env.reset()\n",
 51 |     "# for _ in range(100):\n",
 52 |     "#     env.render()\n",
 53 |     "#     time.sleep(0.01)\n",
 54 |     "#     env.step(env.action_space.sample())   # take random actions  \n",
 55 |     "# env.close()"
 56 |    ]
 57 |   },
 58 |   {
 59 |    "cell_type": "markdown",
 60 |    "metadata": {},
 61 |    "source": [
 62 |     "### Checking for cuda device"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": 3,
 68 |    "metadata": {},
 69 |    "outputs": [
 70 |     {
 71 |      "name": "stdout",
 72 |      "output_type": "stream",
 73 |      "text": [
 74 |       "cuda\n"
 75 |      ]
 76 |     }
 77 |    ],
 78 |    "source": [
 79 |     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
 80 |     "print(device)"
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "markdown",
 85 |    "metadata": {},
 86 |    "source": [
 87 |     "### Initialization of Hyperparameters"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "code",
 92 |    "execution_count": 4,
 93 |    "metadata": {},
 94 |    "outputs": [
 95 |     {
 96 |      "name": "stdout",
 97 |      "output_type": "stream",
 98 |      "text": [
 99 |       "1\n"
100 |      ]
101 |     }
102 |    ],
103 |    "source": [
104 |     "LEARNING_RATE = 0.001\n",
105 |     "DISCOUNT = 0.99\n",
106 |     "EPS = 1\n",
107 |     "EPS_DECAY = 0.9999\n",
108 |     "END_EPS = 0.1\n",
109 |     "\n",
110 |     "N_EPISODE = 1500\n",
111 |     "\n",
112 |     "\n",
113 |     "# Dimensions of input and output of environment\n",
114 |     "obs_dim = env.observation_space.shape[0]\n",
115 |     "action_dim = env.action_space.shape[0]\n",
116 |     "print(action_dim)"
117 |    ]
118 |   },
119 |   {
120 |    "cell_type": "markdown",
121 |    "metadata": {},
122 |    "source": [
123 |     "### Actor Network"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "code",
128 |    "execution_count": 5,
129 |    "metadata": {},
130 |    "outputs": [],
131 |    "source": [
132 |     "class Actor(nn.Module):\n",
133 |     "    def __init__(self, observations, actions):\n",
134 |     "        super(Actor, self).__init__()\n",
135 |     "        self.actor = nn.Sequential(\n",
136 |     "            nn.Linear(observations, 32),\n",
137 |     "            nn.ReLU(),\n",
138 |     "            nn.Linear(32, 16),\n",
139 |     "            nn.ReLU()\n",
140 |     "        )\n",
141 |     "        self.l1 = nn.Linear(16, actions)\n",
142 |     "        self.l2 = nn.Linear(16, actions)\n",
143 |     "        \n",
144 |     "    def forward(self, x):\n",
145 |     "        x = self.actor(x)\n",
146 |     "        mean = self.l1(x)\n",
147 |     "        variance = F.softplus(self.l2(x))\n",
148 |     "        \n",
149 |     "        return mean, variance"
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": 6,
155 |    "metadata": {},
156 |    "outputs": [],
157 |    "source": [
158 |     "actor = Actor(obs_dim, action_dim).to(device)\n",
159 |     "optimizerA = optim.Adam(actor.parameters(), lr = LEARNING_RATE)"
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "markdown",
164 |    "metadata": {},
165 |    "source": [
166 |     "### Sampling of action from Normal Distribution"
167 |    ]
168 |   },
169 |   {
170 |    "cell_type": "code",
171 |    "execution_count": 7,
172 |    "metadata": {},
173 |    "outputs": [],
174 |    "source": [
175 |     "def actors_action(state):\n",
176 |     "    \n",
177 |     "    mean, variance = actor(state)\n",
178 |     "    \n",
179 |     "    dist = torch.distributions.Normal(mean, torch.sqrt(variance))\n",
180 |     "    action = dist.sample()\n",
181 |     "    log_prob = dist.log_prob(action).sum(-1).unsqueeze(-1)\n",
182 |     "    \n",
183 |     "    return action.detach().cpu().numpy(), log_prob"
184 |    ]
185 |   },
186 |   {
187 |    "cell_type": "markdown",
188 |    "metadata": {},
189 |    "source": [
190 |     "### Critic Network"
191 |    ]
192 |   },
193 |   {
194 |    "cell_type": "code",
195 |    "execution_count": 8,
196 |    "metadata": {},
197 |    "outputs": [],
198 |    "source": [
199 |     "class Critic(nn.Module):\n",
200 |     "    def __init__(self, observations):\n",
201 |     "        super(Critic, self).__init__()\n",
202 |     "        self.network = nn.Sequential(\n",
203 |     "            nn.Linear(observations, 64),\n",
204 |     "            nn.ReLU(),\n",
205 |     "            nn.Linear(64, 32),\n",
206 |     "            nn.ReLU(),\n",
207 |     "            nn.Linear(32, 1)\n",
208 |     "        )\n",
209 |     "    \n",
210 |     "    def forward(self, x):\n",
211 |     "        return self.network(x)"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "code",
216 |    "execution_count": 9,
217 |    "metadata": {},
218 |    "outputs": [],
219 |    "source": [
220 |     "critic = Critic(obs_dim).to(device)\n",
221 |     "optimizerC = optim.Adam(critic.parameters(), lr = LEARNING_RATE)\n",
222 |     "criterionC = nn.MSELoss().to(device)"
223 |    ]
224 |   },
225 |   {
226 |    "cell_type": "markdown",
227 |    "metadata": {},
228 |    "source": [
229 |     "### Computing Q-Values"
230 |    ]
231 |   },
232 |   {
233 |    "cell_type": "code",
234 |    "execution_count": 10,
235 |    "metadata": {},
236 |    "outputs": [],
237 |    "source": [
238 |     "def compute_returns(next_state, rewards, done, discount = DISCOUNT):\n",
239 |     "#     q_val = critic(state)\n",
240 |     "\n",
241 |     "    next_state = torch.FloatTensor(next_state).to(device)\n",
242 |     "    next_q_val = critic(next_state)\n",
243 |     "    returns = []\n",
244 |     "    \n",
245 |     "    for step in reversed(range(len(rewards))):\n",
246 |     "        next_q_val = rewards[step] + discount*next_q_val*(1-done[step])\n",
247 |     "        returns.append(next_q_val)\n",
248 |     "        \n",
249 |     "    returns.reverse()\n",
250 |     "    return returns\n",
251 |     "    "
252 |    ]
253 |   },
254 |   {
255 |    "cell_type": "markdown",
256 |    "metadata": {},
257 |    "source": [
258 |     "### Updating Actor based on Q-values by critic"
259 |    ]
260 |   },
261 |   {
262 |    "cell_type": "code",
263 |    "execution_count": 11,
264 |    "metadata": {},
265 |    "outputs": [],
266 |    "source": [
267 |     "def ACupdate(log_probs, ret, values):\n",
268 |     "    optimizerA.zero_grad()\n",
269 |     "    optimizerC.zero_grad()\n",
270 |     "    \n",
271 |     "    actor_loss = 0\n",
272 |     "    critic_loss = 0\n",
273 |     "\n",
274 |     "    for log_prob, value, retr in zip(log_probs, values, ret):\n",
275 |     "                \n",
276 |     "        actor_loss -= log_prob*retr\n",
277 |     "#         print('AL', actor_loss)\n",
278 |     "        \n",
279 |     "#         print(criterionC(value, retr))\n",
280 |     "        critic_loss += criterionC(retr.detach(), value)\n",
281 |     "        \n",
282 |     "    actor_loss.backward()\n",
283 |     "    critic_loss.backward()\n",
284 |     "    \n",
285 |     "    optimizerA.step()\n",
286 |     "    optimizerC.step()\n",
287 |     "    \n",
288 |     "    return (actor_loss+critic_loss).item()"
289 |    ]
290 |   },
291 |   {
292 |    "cell_type": "code",
293 |    "execution_count": 12,
294 |    "metadata": {},
295 |    "outputs": [],
296 |    "source": [
297 |     "mean_avg = []\n",
298 |     "\n",
299 |     "def plot(n_rewards, loss):\n",
300 |     "    clear_output(True)\n",
301 |     "    plt.figure(figsize=(30,6))\n",
302 |     "    mean = np.mean(n_rewards[-10:])\n",
303 |     "    plt.subplot(131)\n",
304 |     "    mean_avg.append(mean)\n",
305 |     "    plt.title('Reward: %s' % (mean))\n",
306 |     "    plt.plot(n_rewards)\n",
307 |     "    plt.plot(mean_avg)\n",
308 |     "    \n",
309 |     "    l = loss[-1]\n",
310 |     "    plt.subplot(132)\n",
311 |     "    plt.title('loss %.2f' %l)\n",
312 |     "    plt.plot(loss)\n",
313 |     "    plt.show()"
314 |    ]
315 |   },
316 |   {
317 |    "cell_type": "markdown",
318 |    "metadata": {},
319 |    "source": [
320 |     "### Training QAC"
321 |    ]
322 |   },
323 |   {
324 |    "cell_type": "code",
325 |    "execution_count": 13,
326 |    "metadata": {},
327 |    "outputs": [
328 |     {
329 |      "data": {
330 |       "image/png": "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\n",
331 |       "text/plain": [
332 |        "<Figure size 2160x432 with 2 Axes>"
333 |       ]
334 |      },
335 |      "metadata": {
336 |       "needs_background": "light"
337 |      },
338 |      "output_type": "display_data"
339 |     }
340 |    ],
341 |    "source": [
342 |     "n_rewards = []\n",
343 |     "losses = []\n",
344 |     "\n",
345 |     "for i in range(1, N_EPISODE+1):\n",
346 |     "    ep_rewards = []\n",
347 |     "    log_probs = []\n",
348 |     "    done_states = []\n",
349 |     "#     returns = []\n",
350 |     "    total_reward = 0\n",
351 |     "    done = False\n",
352 |     "    values = []\n",
353 |     "    \n",
354 |     "    state = env.reset()\n",
355 |     "    ret = 0\n",
356 |     "    \n",
357 |     "    while not done:\n",
358 |     "        state = torch.FloatTensor(state).to(device)\n",
359 |     "        action, log_prob = actors_action(state)\n",
360 |     "        \n",
361 |     "        value = critic(state)\n",
362 |     "        next_state, reward, done, _ = env.step(action)\n",
363 |     "        \n",
364 |     "        \n",
365 |     "        done = torch.tensor([done], dtype = torch.float, device = device)\n",
366 |     "        \n",
367 |     "        ep_rewards.append(torch.tensor([reward], dtype = torch.float, device = device))\n",
368 |     "        log_probs.append(log_prob)\n",
369 |     "        done_states.append(done)\n",
370 |     "        values.append(value)\n",
371 |     "\n",
372 |     "        total_reward += reward\n",
373 |     "#         ret = compute_returns(next_state, reward, done, ret)\n",
374 |     "#         if i%5 == 0:\n",
375 |     "#             env.render()\n",
376 |     "        state = next_state\n",
377 |     "        \n",
378 |     "    q_vals = compute_returns(next_state, ep_rewards, done_states)\n",
379 |     "    \n",
380 |     "    loss = ACupdate(log_probs, q_vals, values)\n",
381 |     "    \n",
382 |     "    n_rewards.append(total_reward)\n",
383 |     "    losses.append(loss)\n",
384 |     "    plot(n_rewards, losses)\n",
385 |     "    \n",
386 |     "    if np.mean(n_rewards[-10:]) == 1000:\n",
387 |     "        torch.save(actor.state_dict(), 'actor.pth')\n",
388 |     "        torch.save(critic.state_dict(), 'critic.pth')\n",
389 |     "        print(\"Model Saved\")"
390 |    ]
391 |   },
392 |   {
393 |    "cell_type": "code",
394 |    "execution_count": 14,
395 |    "metadata": {},
396 |    "outputs": [
397 |     {
398 |      "ename": "FileNotFoundError",
399 |      "evalue": "[Errno 2] No such file or directory: '/home/himanshu/1.RL/Policy-based-RL/actor.pth'",
400 |      "output_type": "error",
401 |      "traceback": [
402 |       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
403 |       "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
404 |       "\u001b[0;32m<ipython-input-14-d6efef3b3f00>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mdone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mactor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_state_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/home/himanshu/1.RL/Policy-based-RL/actor.pth'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mcritic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_state_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/home/himanshu/1.RL/Policy-based-RL/critic.pth'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Model Loaded\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
405 |       "\u001b[0;32m~/anaconda3/envs/rl/lib/python3.8/site-packages/torch/serialization.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, **pickle_load_args)\u001b[0m\n\u001b[1;32m    582\u001b[0m         \u001b[0mpickle_load_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'encoding'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'utf-8'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    583\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m     \u001b[0;32mwith\u001b[0m \u001b[0m_open_file_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mopened_file\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    585\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0m_is_zipfile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopened_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    586\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0m_open_zipfile_reader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mopened_zipfile\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
406 |       "\u001b[0;32m~/anaconda3/envs/rl/lib/python3.8/site-packages/torch/serialization.py\u001b[0m in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m    232\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_open_file_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    233\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0m_is_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 234\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_open_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    235\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;34m'w'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
407 |       "\u001b[0;32m~/anaconda3/envs/rl/lib/python3.8/site-packages/torch/serialization.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0m_open_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_opener\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    214\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 215\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_open_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    216\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    217\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__exit__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
408 |       "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/himanshu/1.RL/Policy-based-RL/actor.pth'"
409 |      ]
410 |     }
411 |    ],
412 |    "source": [
413 |     "state = env.reset()\n",
414 |     "\n",
415 |     "\n",
416 |     "total_reward = 0\n",
417 |     "done = False\n",
418 |     "\n",
419 |     "actor.load_state_dict(torch.load('/home/himanshu/1.RL/Policy-based-RL/actor.pth'))\n",
420 |     "critic.load_state_dict(torch.load('/home/himanshu/1.RL/Policy-based-RL/critic.pth'))\n",
421 |     "print(\"Model Loaded\")\n",
422 |     "actor.to(device)\n",
423 |     "critic.to(device)\n",
424 |     "\n",
425 |     "while not done:\n",
426 |     "    state = torch.FloatTensor(state).to(device)\n",
427 |     "    action, log_prob = actors_action(state)\n",
428 |     "    \n",
429 |     "    next_state, reward, done, _ = env.step(action)\n",
430 |     "    total_reward += reward\n",
431 |     "    \n",
432 |     "    env.render()\n",
433 |     "    time.sleep(0.01)\n",
434 |     "    \n",
435 |     "    state = next_state\n",
436 |     "    \n",
437 |     "print('Duration till which pole is balanced: ', total_reward)\n",
438 |     "\n",
439 |     "env.close()"
440 |    ]
441 |   },
442 |   {
443 |    "cell_type": "code",
444 |    "execution_count": null,
445 |    "metadata": {},
446 |    "outputs": [],
447 |    "source": []
448 |   }
449 |  ],
450 |  "metadata": {
451 |   "kernelspec": {
452 |    "display_name": "Python 3",
453 |    "language": "python",
454 |    "name": "python3"
455 |   },
456 |   "language_info": {
457 |    "codemirror_mode": {
458 |     "name": "ipython",
459 |     "version": 3
460 |    },
461 |    "file_extension": ".py",
462 |    "mimetype": "text/x-python",
463 |    "name": "python",
464 |    "nbconvert_exporter": "python",
465 |    "pygments_lexer": "ipython3",
466 |    "version": "3.8.1"
467 |   }
468 |  },
469 |  "nbformat": 4,
470 |  "nbformat_minor": 4
471 | }
472 | 


--------------------------------------------------------------------------------