def test_encode(self):
encoder = get_encoder_by_name('oneplane', 9)
gs = GameState.new_game(9)
gs = gs.apply_move(Move.play(Point(5, 5)))
gs = gs.apply_move(Move.play(Point(4, 5)))
code = encoder.encode(gs)
self.assertEqual(1, code[0][4][4])
self.assertEqual(-1, code[0][3][4])
def load_ac_agent(h5file):
model = load_model_from_hdf5_group(h5file['model'])
encoder_name = h5file['encoder'].attrs['name']
if not isinstance(encoder_name, str):
encoder_name = encoder_name.decode('ascii')
board_sz = h5file['encoder'].attrs['board_sz']
encoder = get_encoder_by_name(encoder_name, board_sz)
return ACAgent(model, encoder)
def load_zero_agent(h5file, eval_rounds=1600, exploration_factor=2.):
model = load_model_from_hdf5_group(h5file['model'])
encoder_name = h5file['encoder'].attrs['name']
if not isinstance(encoder_name, str):
encoder_name = encoder_name.decode('ascii')
board_sz = h5file['encoder'].attrs['board_sz']
encoder = get_encoder_by_name(encoder_name, board_sz)
return ZeroAgent(model, encoder, eval_rounds, exploration_factor)
def test_encode(self):
encoder = get_encoder_by_name('sevenplane', 9)
gs = GameState.new_game(9)
gs = gs.apply_move(Move.play(Point(2, 7)))
gs = gs.apply_move(Move.play(Point(7, 2)))
gs = gs.apply_move(Move.play(Point(3, 6)))
gs = gs.apply_move(Move.play(Point(6, 3)))
gs = gs.apply_move(Move.play(Point(3, 7)))
gs = gs.apply_move(Move.play(Point(2, 6)))
gs = gs.apply_move(Move.play(Point(2, 5)))
code = encoder.encode(gs)
self.assertEqual(1., code[0][1][5])
def load_agent(agent_path, args):
if not os.path.isfile(agent_path):
#if agent does not exist yet, create a new one, and save it
encoder = get_encoder_by_name(args.encoder_name, args.board_size)
if args.model_size == 'small':
from rlgames.rl_models.zero_small import zero_model
model = zero_model(encoder)
else:
raise ValueError('Unknown model size: {}'.format(args.model_size))
agent = ZeroAgent(model, encoder)
agent.serialize(h5py.File(agent_path, 'w'))
agent = load_zero_agent(h5py.File(agent_path, 'r'))
return agent
def __init__(self, data_directory, encoder='oneplane'):
self.encoder = get_encoder_by_name(encoder, 19)
self.data_dir = data_directory
def test_decode_index(self):
encoder = get_encoder_by_name('elevenplane', 9)
pt = encoder.decode_point_index(16)
self.assertEqual(Point(2, 8), pt)
def test_encode_point(self):
encoder = get_encoder_by_name('elevenplane', 9)
pt = Point(2, 2)
idx = encoder.encode_point(pt)
self.assertEqual(10, idx)
def test_create(self):
encoder = get_encoder_by_name('oneplane', 9)
self.assertTrue(encoder is not None)
def test_shape(self):
encoder = get_encoder_by_name('sevenplane', 9)
shape = encoder.shape()
self.assertEqual(7, shape[0])
self.assertEqual(9, shape[1])
self.assertEqual(9, shape[2])
def test_num_points(self):
encoder = get_encoder_by_name('sevenplane', 9)
self.assertEqual(81, encoder.num_points())
import h5py
from keras.models import Sequential
from keras.layers import Dense
from rlgames.agents.predict import DeepLearningAgent, load_prediction_agent
from rlgames.data_processor.parallel_processor import DataProcessor
from rlgames.encoders.base import get_encoder_by_name
from rlgames.httpfrontend import get_web_app
from rlgames.imitation_models.small import layers
board_sz = 19
nb_classes = board_sz * board_sz
encoder = get_encoder_by_name('oneplane', board_sz)
processor = DataProcessor('/home/armandli/rlgames/data',
encoder=encoder.name())
X, y = processor.load_data(num_samples=100)
input_shape = (encoder.num_planes, board_sz, board_sz)
model = Sequential()
network_layers = layers(input_shape)
for layer in network_layers:
model.add(layer)
model.add(Dense(nb_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
model.fit(X, y, batch_size=128, epochs=20, verbose=1)
def load_policy_agent(h5file):
model = load_model_from_hdf5_group(h5file['model'])
encoder_name = h5file['encoder'].attrs['name']
board_sz = h5file['encoder'].attrs['board_sz']
encoder = get_encoder_by_name(encoder_name, board_sz)
return PolicyAgent(model, encoder)
