def __init__(self,
game='classic_kong',
obs_type='ram',
frameskip=(2, 5),
repeat_action_probability=0.):
"""Frameskip should be either a tuple (indicating a random range to
choose from, with the top value exclude), or an int."""
utils.EzPickle.__init__(self, game, obs_type)
assert obs_type in ('ram', 'image')
self.game_path = self.get_rom_path(game)
self._obs_type = obs_type
self.frameskip = frameskip
self.rle = RLEInterface()
self.viewer = None
# Tune (or disable) RLE's action repeat:
# https://github.com/openai/gym/issues/349
assert isinstance(
repeat_action_probability,
(float, int)), "Invalid repeat_action_probability: {!r}".format(
repeat_action_probability)
self.rle.setFloat('repeat_action_probability'.encode('utf-8'),
repeat_action_probability)
self._seed()
(screen_width, screen_height) = self.rle.getScreenDims()
self._buffer = np.empty((screen_height, screen_width, 4),
dtype=np.uint8)
self._action_set = self.rle.getMinimalActionSet()
self.action_space = spaces.Discrete(len(self._action_set))
(screen_width, screen_height) = self.rle.getScreenDims()
ram_size = self.rle.getRAMSize()
if self._obs_type == 'ram':
self.observation_space = spaces.Box(low=np.zeros(ram_size),
high=np.zeros(ram_size) + 255)
elif self._obs_type == 'image':
self.observation_space = spaces.Box(low=0,
high=255,
shape=(
screen_height,
screen_width,
))
else:
raise error.Error('Unrecognized observation type: {}'.format(
self._obs_type))
#!/usr/bin/env python
# python_example.py
# Author: Ben Goodrich
# Modified by: Nadav Bhonker and Shai Rozenberg
#
# This is a direct port to python of the shared library example from
# RLE provided in doc/examples/sharedLibraryInterfaceExample.cpp
import sys
from random import randrange
from rle_python_interface import RLEInterface
if len(sys.argv) < 2:
print('Usage:', sys.argv[0], 'rom_file', 'core_file')
sys.exit()
rle = RLEInterface()
# Get & Set the desired settings
rle.setInt('random_seed', 123)
# Set USE_SDL to true to display the screen. RLE must be compilied
# with SDL enabled for this to work. On OSX, pygame init is used to
# proxy-call SDL_main.
USE_SDL = False
if USE_SDL:
if sys.platform == 'darwin':
import pygame
pygame.init()
rle.setBool('sound', False) # Sound doesn't work on OSX
elif sys.platform.startswith('linux'):
rle.setBool('sound', True)
# RLE provided in doc/examples/sharedLibraryInterfaceExample.cpp
import sys
from random import randrange
from rle_python_interface import RLEInterface
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Embedding, LSTM, Bidirectional, Activation, Conv2D, Lambda, Flatten
from keras import optimizers
from collections import deque
if len(sys.argv) < 2:
print('Usage:', sys.argv[0], 'rom_file', 'core_file')
sys.exit()
rle = RLEInterface()
# Get & Set the desired settings
rle.setInt(b'random_seed', 42)
#rle.setString(b'MK_player1_character', b'scorpion')
# Set USE_SDL to true to display the screen. RLE must be compilied
# with SDL enabled for this to work. On OSX, pygame init is used to
# proxy-call SDL_main.
USE_SDL = True
if USE_SDL:
if sys.platform == 'darwin':
import pygame
pygame.init()
#rle.setBool(b'sound', False) # Sound doesn't work on OSX
elif sys.platform.startswith('linux'):
def setUp(self):
cwd = os.getcwd()
core = 'snes'
romName = os.path.join(cwd, 'roms', 'classic_kong.smc')
self.rle = RLEInterface()
self.rle.loadROM(romName, core)
class RleTest(unittest.TestCase):
def setUp(self):
cwd = os.getcwd()
core = 'snes'
romName = os.path.join(cwd, 'roms', 'classic_kong.smc')
self.rle = RLEInterface()
self.rle.loadROM(romName, core)
def test_ram(self):
ram_size = self.rle.getRAMSize()
self.assertEqual(128 * 1024, ram_size)
ram = np.array(ram_size, dtype=np.uint8)
ram = self.rle.getRAM()
self.assertIsNotNone(ram[0])
self.assertIsNotNone(ram[ram_size - 1])
def test_getScreenRGB(self):
dimensions = self.rle.getScreenDims()
self.assertEqual(dimensions[0], 256)
self.assertEqual(dimensions[1], 224)
screen_data = np.empty((dimensions[1], dimensions[0], 4),
dtype=np.uint8)
for _ in range(10):
self.rle.act(0)
self.rle.getScreenRGB(screen_data=screen_data)
self.rle.getScreenGrayscale(screen_data=screen_data)
def test_getScreenGrayscale(self):
dimensions = self.rle.getScreenDims()
self.assertEqual(dimensions[0], 256)
self.assertEqual(dimensions[1], 224)
screen_data = np.empty((dimensions[1], dimensions[0]), dtype=np.uint8)
self.assertEqual(224 * 256, screen_data.size)
for _ in range(100):
self.rle.act(0)
self.rle.getScreenGrayscale(screen_data=screen_data)
if self.epsilon > self.epsilon_min:
self.epsilon *= self.epsilon_decay
def load(self, name):
self.model.load_weights(name)
def save(self, name):
self.model.save_weights(name)
if __name__ == "__main__":
if len(sys.argv) < 2:
print('Usage:', sys.argv[0], 'rom_file', 'core_file')
sys.exit()
rle = RLEInterface()
rle.setInt(b'random_seed', 42)
USE_SDL = True
if USE_SDL:
if sys.platform == 'darwin':
import pygame
pygame.init()
#rle.setBool(b'sound', False) # Sound doesn't work on OSX
elif sys.platform.startswith('linux'):
#rle.setBool(b'sound', True)
rle.setBool(b'display_screen', True)
# Load the ROM file
rle.loadROM(sys.argv[1], sys.argv[2])
width, height = rle.getScreenDims()
#!/usr/bin/env python
# python_example.py
# Author: Ben Goodrich
#
# This is a direct port to python of the shared library example from
# ALE provided in doc/examples/sharedLibraryInterfaceExample.cpp
import sys
from random import randrange
from rle_python_interface import RLEInterface
if len(sys.argv) < 2:
print 'Usage:', sys.argv[0], 'rom_file'
sys.exit()
rle = RLEInterface()
# Get & Set the desired settings
rle.setInt('random_seed', 123)
# Set USE_SDL to true to display the screen. ALE must be compilied
# with SDL enabled for this to work. On OSX, pygame init is used to
# proxy-call SDL_main.
USE_SDL = False
if USE_SDL:
if sys.platform == 'darwin':
import pygame
pygame.init()
rle.setBool('sound', False) # Sound doesn't work on OSX
elif sys.platform.startswith('linux'):
rle.setBool('sound', True)
rle.setBool('display_screen', True)
class RleEnv(gym.Env, utils.EzPickle):
metadata = {'render.modes': ['human', 'rgb_array']}
def __init__(self,
game='classic_kong',
obs_type='ram',
frameskip=(2, 5),
repeat_action_probability=0.):
"""Frameskip should be either a tuple (indicating a random range to
choose from, with the top value exclude), or an int."""
utils.EzPickle.__init__(self, game, obs_type)
assert obs_type in ('ram', 'image')
self.game_path = self.get_rom_path(game)
self._obs_type = obs_type
self.frameskip = frameskip
self.rle = RLEInterface()
self.viewer = None
# Tune (or disable) RLE's action repeat:
# https://github.com/openai/gym/issues/349
assert isinstance(
repeat_action_probability,
(float, int)), "Invalid repeat_action_probability: {!r}".format(
repeat_action_probability)
self.rle.setFloat('repeat_action_probability'.encode('utf-8'),
repeat_action_probability)
self._seed()
(screen_width, screen_height) = self.rle.getScreenDims()
self._buffer = np.empty((screen_height, screen_width, 4),
dtype=np.uint8)
self._action_set = self.rle.getMinimalActionSet()
self.action_space = spaces.Discrete(len(self._action_set))
(screen_width, screen_height) = self.rle.getScreenDims()
ram_size = self.rle.getRAMSize()
if self._obs_type == 'ram':
self.observation_space = spaces.Box(low=np.zeros(ram_size),
high=np.zeros(ram_size) + 255)
elif self._obs_type == 'image':
self.observation_space = spaces.Box(low=0,
high=255,
shape=(
screen_height,
screen_width,
))
else:
raise error.Error('Unrecognized observation type: {}'.format(
self._obs_type))
def get_rom_path(self, game):
cwd = os.path.dirname(__file__)
roms_path = os.path.join(cwd, 'roms')
for file in os.listdir(roms_path):
if fnmatch.fnmatch(file, game + '*'):
return os.path.join(roms_path, file)
def _seed(self, seed=None):
self.np_random, seed1 = seeding.np_random(seed)
# Derive a random seed. This gets passed as a uint, but gets
# checked as an int elsewhere, so we need to keep it below
# 2**31.
seed2 = seeding.hash_seed(seed1 + 1) % 2**31
# Empirically, we need to seed before loading the ROM.
self.rle.setInt(b'random_seed', seed2)
self.rle.loadROM(self.game_path, 'snes')
return [seed1, seed2]
def _step(self, a):
reward = 0.0
action = self._action_set[a]
if isinstance(self.frameskip, int):
num_steps = self.frameskip
else:
num_steps = self.np_random.randint(self.frameskip[0],
self.frameskip[1])
for _ in range(num_steps):
reward += self.rle.act(action)
ob = self._get_obs()
return ob, reward, self.rle.game_over(), {
"rle.lives": self.rle.lives()
}
def _get_image(self):
self.rle.getScreenRGB(self._buffer)
return self._buffer[:, :, [0, 1, 2]]
def _get_ram(self):
return to_ram(self.rle)
@property
def _n_actions(self):
return len(self._action_set)
def _get_obs(self):
if self._obs_type == 'ram':
return self._get_ram()
if self._obs_type == 'image':
return self._get_image()
def _reset(self):
self.rle.reset_game()
return self._get_obs()
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
img = self._get_image()
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
def get_action_meanings(self):
return [get_action_meaning(i) for i in self._action_set]