Kernel crashed while executing #11221
Answered
by
n1ghtf4l1
n1ghtf4l1
asked this question in
Questions and Answers
-
Environment data
Expected behaviourIt is expected that when we the following code the output should display this: Actual behaviourIt is showing this in the output on the jupyter when run: Steps to reproduce:
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision.transforms as T
from IPython import display
import matplotlib.pyplot as plt
import gym
import numpy as np
class CartPoleEnvManager:
def __init__(self, device) -> None:
"""
(UPDATE!)
we're no longer dealing with screen frames to determine the environment
states, the class no longer has a `current_screen` attribute.
Instead, we now have a `current_state` attribute, which is initialized to None.
"""
self.device = device
# to access the tools that
self.env = gym.make('CartPole-v1').unwrapped
# we won't access in the normal intialization
self.env.reset() # reset the environment to get the initial observations
self.current_screen = None # No longer available
self.current_state = None
self.done = False
def reset(self) -> None:
"""
(UPDATE!)
Function now resets its `current_state` to the initial observation returned
by the Gym environment when its reset, rather than resetting the screen
as was implemented previously.
"""
self.current_state = self.env.reset()
def close(self) -> None:
self.env.close()
def render(self, mode='human'):
return self.env.render(mode)
def display(self):
return self.env.display()
def num_actions_available(self):
"""checking number of actions available in the environment –
we have two options [<left, right>]
"""
return self.env.action_space.n
def take_action(self, action: torch.Tensor) -> torch.Tensor:
"""
(UPDATE!)
We would not store the state returned by `env.step()` since we were not
making use of it. Now, since we're using the returned state, rather than
the screen frames, we store the state returned by `step()`
in the class's `current_state` attribute.
"""
# _, reward, self.done, _ = self.env.step(action.item()) # .item() is refer to our element inside the tensor
self.current_state, reward, self.done, _ = self.env.step(action.item())
return torch.tensor([reward], device=self.device)
def get_state(self):
"""
(UPDATE!)
Previously, this function would return the pixel data that resulted from
the difference of the last two screen frames rendered in the environment.
Now, we simply return the state of the environment that we've stored in
the class's current_state attribute.
"""
if self.done:
return torch.zeros_like(
torch.tensor(self.current_state, device=self.device)
).float()
else:
return torch.tensor(self.current_state, device=self.device).float()
def num_state_features(self):
"""
(NEW!)
Returns the number of features included in a state returned by the Gym environment.
This is so that we can know the size of states that will be passed to the
network as input.
"""
return self.env.observation_space.shape[0]
# ------------------------------------------------------------------------------
"""
(UPDATE!)
We no longer need any of the functions that we previously used for
screen processing, and so they can all be deleted. These include:
- get_screen_height()
- get_screen_width()
- get_processed_screen()
- crop_screen()
- transform_screen_data()
- just_starting()
"""
def image_reset(self) -> None:
self.env.reset()
self.current_screen = None # for resetting the screen to the first screen
def get_image_state(self):
"""Return the current state of the environment in the form of
a processed image of the screen.
"""
if self.just_starting() or self.done:
# if we're at the start of at the end of the proccess, we initialize
# the image as a black screen.
self.current_screen = self.get_processed_screen()
black_screen = torch.zeros_like(self.current_screen)
return black_screen
else:
# current screen
s1 = self.current_screen
# call a new screen (the next screen)
s2 = self.get_processed_screen()
# make the next screen is the current screen
self.current_screen = s2
# return the difference between two screens to get the current state
return s2 - s1
def just_starting(self) -> bool:
"""Check whether the the current screen is None or not
This help to check if we're at the start of the environment or not!
"""
return self.current_screen is None
def get_screen_height(self) -> int:
screen = self.get_processed_screen()
return screen.shape[2]
def get_screen_width(self) -> int:
screen = self.get_processed_screen()
return screen.shape[3]
def get_processed_screen(self):
"""Get the image's color channels then transpose the channels
into the order of channels by height and width which what PyTorch DQN expect
"""
screen = self.render('rgb_array').transpose((2, 0, 1))
screen = self.crop_screen(screen)
return self.transform_screen_data(screen)
def crop_screen(self, screen):
"""Except screen and will return a cropped version of it"""
screen_height = screen.shape[1]
# strip off top and bottom
top = int(screen_height * 0.4)
bottom = int(screen_height * 0.8)
# we cropped 40% of the top of the screen & 20% of the bottom of the screen
screen = screen[:, top:bottom, :]
return screen
def transform_screen_data(self, screen):
# Convert to float, rescale, convert to tensor
screen = np.ascontiguousarray(screen, # This array return contiguous array of the same as screen but transformed
dtype=np.float32) / 255 # these values here will be stored sequencially in the memory
screen = torch.from_numpy(screen)
# Use `torchvision` package to compose several image transformations
resize = T.Compose([
T.ToPILImage(), # Convert the image to pill image
T.Resize((40, 90)), # resize the image to 40x90
T.ToTensor() # convert it to tensor
])
# Unsqueeze should add another dimension which represents the batch dim
## since the processed images will be passed to the dqn in batches.
return resize(screen).unsqueeze(0).to(self.device)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
image_em = CartPoleEnvManager(device)
image_em.image_reset()
screen = image_em.render('rgb_array')
plt.figure()
plt.imshow(screen)
plt.title('None-processed Screen Example')
plt.show()I have nvcc version 11.7; Pytorch version 1.12.0(stable); openai gym version 0.7.4 Jupyter Notebook LogsOutput for
|
Beta Was this translation helpful? Give feedback.
Answered by
n1ghtf4l1
Aug 30, 2022
Replies: 1 comment
-
|
I solved the issue after hours of searching the internet. I debugged the issue and found out there was a file called libstc++.so.6 in my conda virtual environment where I was running this program, that didn't have the required version of GLIBCXX_3.4.15. So, I replaced that file from the one that was created on my global environment i.e in usr/lib/ because I tested the same program by running on the global environment and it worked just fine. Now it works fine even in the virtual environment. |
Beta Was this translation helpful? Give feedback.
0 replies
Answer selected by
n1ghtf4l1
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
I solved the issue after hours of searching the internet. I debugged the issue and found out there was a file called libstc++.so.6 in my conda virtual environment where I was running this program, that didn't have the required version of GLIBCXX_3.4.15.
So, I replaced that file from the one that was created on my global environment i.e in usr/lib/ because I tested the same program by running on the global environment and it worked just fine. Now it works fine even in the virtual environment.