I got FatalError: gladLoadGL error while trying to perform reinforcement learning

[ppyakksa]

Hi,

I'm a student and I'm trying to use MuJoCo for simulate crane automation by using PPO.

I'm looking for some help with fixing error FatalError: gladLoadGL.

I have attached four cameras to a rotating box and I am trying to get images from the cameras.
Getting the images works well when I run the code independently.
But I get fladLoadGL error when I am trying to load the image while reinforcement learning

Here is the code that doesn't work. I am using .ipynb

#cell [15]
from OpenGL.EGL import *

os.environ['MUJOCO_GL'] = 'egl'

def get_camera_images(model, data, camera_names, width=224, height=224):

images = []

offscreen = mujoco.MjrContext(model, mujoco.mjtFontScale.mjFONTSCALE_150)

# Iterate over the camera names and render each one
for i, camera_name in enumerate(camera_names):
    camera_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_CAMERA, camera_name)
    
    cam = mujoco.MjvCamera()
    cam.fixedcamid = camera_id
    cam.type = mujoco.mjtCamera.mjCAMERA_FIXED
    
    scene = mujoco.MjvScene(model, maxgeom=1000)
    mujoco.mjv_updateScene(model, data, mujoco.MjvOption(), None, cam, mujoco.mjtCatBit.mjCAT_ALL, scene)
    viewport = mujoco.MjrRect(0, 0, width, height)
    mujoco.mjr_render(viewport, scene, offscreen)
    
    rgb_array = np.zeros((height, width, 3), dtype=np.uint8)
    mujoco.mjr_readPixels(rgb_array, None, viewport, offscreen)
    
    rgb_array = np.flipud(rgb_array)
    
    # Rotate the images as needed
    if camera_name == 'control_cabin_camera_1':
        rgb_array = np.rot90(rgb_array, k=1)  # Counterclockwise by 90 degrees
    elif camera_name == 'control_cabin_camera_4':
        rgb_array = np.rot90(rgb_array, k=-1)  # Clockwise by 90 degrees
    
    images.append(rgb_array)  
concatenated_image = np.concatenate(images, axis=1)

return concatenated_image

def get_resnet_features(images):
with torch.no_grad():
features = resnet_extractor(images)
return features

#cell[16]
class CustomMujocoEnv(gym.Env):
def init(self, model_path, camera_names):
super(CustomMujocoEnv, self).init()
self.model = mujoco.MjModel.from_xml_path(model_path)
self.data = mujoco.MjData(self.model)
self.camera_names = camera_names
self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(4, 2048), dtype=np.float32)
self.action_space = gym.spaces.Box(low=-1, high=1, shape=(3,), dtype=np.float32)

def reset(self):
    mujoco.mj_resetData(self.model, self.data)
    mujoco.mj_forward(self.model, self.data)
    return self._get_obs()

def step(self, action):
    self.data.ctrl[0] = action[0]
    self.data.ctrl[1] = action[1]
    self.data.ctrl[2] = action[2]
    mujoco.mj_step(self.model, self.data)
    obs = self._get_obs()
    reward = 0  # Define your reward function
    done = False  # Define your done condition
    info = {}
    return obs, reward, done, info

def _get_obs(self):
    images = get_camera_images(self.model, self.data, self.camera_names)

    tensor_images = preprocess(images)  
    tensor_images = tensor_images.unsqueeze(0)      
    features = get_resnet_features(tensor_images)
    return features.numpy().squeeze()

#cell[17]
import os

os.environ['MUJOCO_GL'] = 'egl'

camera_names = [
'control_cabin_camera_1',
'control_cabin_camera_2',
'control_cabin_camera_3',
'control_cabin_camera_4'
]

env = CustomMujocoEnv('Model_xml/model.xml', camera_names)
agent = PPOAgent()
actor_losses, critic_losses, scores, episode, score = [], [], [], 0, 0

for step in range(run_step + test_step):
if step == run_step:
if train_mode:
agent.save_model()
print("test start!")
train_mode = False

state = env.reset()
action = agent.get_action(state, train_mode)
next_state, reward, done, _ = env.step(action)
score += reward
if train_mode:
    agent.append_sample(state, action, [reward], next_state, [done])
    if (step + 1) % n_step == 0:
        actor_loss, critic_loss = agent.train_model()
        actor_losses.append(actor_loss)
        critic_losses.append(critic_loss)

if done:
    episode += 1
    scores.append(score)
    score = 0

    if episode % print_interval == 0:
        mean_score = np.mean(scores)
        mean_actor_loss = np.mean(actor_losses) if len(actor_losses) > 0 else 0
        mean_critic_loss = np.mean(critic_losses) if len(critic_losses) > 0 else 0
        agent.write_summary(mean_score, mean_actor_loss, mean_critic_loss, step)
        actor_losses, critic_losses, scores = [], [], []

        print(f"EP. {episode} / step: {step} / score: {mean_score:.2f} / actor loss: {mean_actor_loss:.2f} / critic loss: {mean_critic_loss:.4f}")

    if train_mode and episode % save_interval == 0:
        agent.save_model()

env.close()

Below is the error code that I got
{
"name": "FatalError",
"message": "gladLoadGL error",
"stack": "---------------------------------------------------------------------------
FatalError Traceback (most recent call last)
Cell In[17], line 25
22 print("test start!")
23 train_mode = False
---> 25 state = env.reset()
26 action = agent.get_action(state, train_mode)
27 next_state, reward, done, _ = env.step(action)

Cell In[16], line 13, in CustomMujocoEnv.reset(self)
11 mujoco.mj_resetData(self.model, self.data)
12 mujoco.mj_forward(self.model, self.data)
---> 13 return self._get_obs()

Cell In[16], line 27, in CustomMujocoEnv._get_obs(self)
26 def _get_obs(self):
---> 27 images = get_camera_images(self.model, self.data, self.camera_names)
29 tensor_images = preprocess(images)
30 tensor_images = tensor_images.unsqueeze(0)

Cell In[15], line 9, in get_camera_images(model, data, camera_names, width, height)
5 os.environ['MUJOCO_GL'] = 'egl'
7 images = []
----> 9 offscreen = mujoco.MjrContext(model, mujoco.mjtFontScale.mjFONTSCALE_150)
11 # Iterate over the camera names and render each one
12 for i, camera_name in enumerate(camera_names):

FatalError: gladLoadGL error"
}

Thank you very much for reading my question. I wish you to have a great day