def __init__(self,
players,
screen_width=400,
screen_height=300,
track='icy_soccer_field'):
assert Tournament._singleton is None, "Cannot create more than one Tournament object"
Tournament._singleton = self
self.graphics_config = pystk.GraphicsConfig.hd()
self.graphics_config.screen_width = screen_width
self.graphics_config.screen_height = screen_height
pystk.init(self.graphics_config)
self.race_config = pystk.RaceConfig(
num_kart=len(players),
track=track,
mode=pystk.RaceConfig.RaceMode.SOCCER)
self.race_config.players.pop()
self.active_players = []
for p in players:
if p is not None:
self.race_config.players.append(p.config)
self.active_players.append(p)
self.k = pystk.Race(self.race_config)
self.k.start()
self.k.step()
def __init__(self, screen_width=128, screen_height=96):
assert PyTux._singleton is None, "Cannot create more than one pytux object"
PyTux._singleton = self
self.config = pystk.GraphicsConfig.hd()
self.config.screen_width = screen_width
self.config.screen_height = screen_height
pystk.init(self.config)
self.k = None
def rollout(num_players=4,
max_steps=1000,
track='icy_soccer_field',
save='train_data_temp'):
config = pystk.GraphicsConfig.hd()
config.screen_width = 400
config.screen_height = 300
pystk.init(config)
race_config = pystk.RaceConfig(num_kart=num_players,
track=track,
mode=pystk.RaceConfig.RaceMode.SOCCER)
race_config.players.pop()
if not os.path.exists(save):
os.makedirs(save)
for i in range(num_players):
o = pystk.PlayerConfig(
controller=pystk.PlayerConfig.Controller.AI_CONTROL,
team=int((i + 1) % 2.0))
race_config.players.append(o)
active_players = race_config.players
print('Number of Players', len(active_players))
k = pystk.Race(race_config)
k.start()
k.step()
# all_images = []
all_actions = []
state = pystk.WorldState()
for t in range(max_steps):
print('step:', t)
state.update()
s = k.step()
t_actions = []
for i in range(num_players):
la = k.last_action[i]
img = np.array(k.render_data[i].image)
a = (img, la.steer, la.acceleration, la.brake)
t_actions.append(a)
if save is not None:
PIL.Image.fromarray(img).save(
os.path.join(save, 'player%02d_%05d.png' % (i, t)))
with open(os.path.join(save, 'player%02d_%05d.csv' % (i, t)),
mode='w') as new_data:
writer = csv.writer(new_data)
writer.writerow(a[1:])
all_actions.append(t_actions)
if not s:
break
print('score', state.soccer.score)
return all_actions
def __init__(self, config: pystk.GraphicsConfig = None):
if config is None:
config = pystk.GraphicsConfig.ld()
config.screen_width = 128
config.screen_height = 96
pystk.init(config)
self.config = None
self.race = None
self.track = None
self.map = None
def main():
config = pystk.GraphicsConfig.hd()
config.screen_width = 800
config.screen_height = 600
pystk.init(config)
config = pystk.RaceConfig()
config.num_kart = 2
# config.track ='battleisland'
config.track = 'stadium'
config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.players[0].team = 0
# NOTE: Add 4 players
for _ in range(3):
config.players.append(
# pystk.PlayerConfig(args.kart, pystk.PlayerConfig.Controller.AI_CONTROL, (args.team + 1) % 2))
pystk.PlayerConfig('', pystk.PlayerConfig.Controller.AI_CONTROL,
1))
config.mode = config.RaceMode.THREE_STRIKES
# TODO: Look at step size?
# config.step_size = args.step_size
race = pystk.Race(config)
race.start()
race.step()
uis = [gui.UI(gui.VT['IMAGE']) for i in range(4)]
state = pystk.WorldState()
state.update()
t0 = time()
if not all(ui.pause for ui in uis):
race.step(uis[0].current_action)
state.update()
for ui, d in zip(uis, race.render_data):
ui.show(d)
input('press enter to continue')
race.stop()
del race
pystk.clean()
def __init__(self, track):
config = pystk.GraphicsConfig.ld()
config.screen_width = 64
config.screen_height = 64
config.render_window = False
pystk.init(config)
race_config = pystk.RaceConfig()
race_config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.track = track
race_config.step_size = 0.1
race_config.render = True
self.race = pystk.Race(race_config)
self.race.start()
self.race.step()
self.track = pystk.Track()
self.track.update()
def __init__(self, _):
print("calling __init__")
gfx_config = pystk.GraphicsConfig.ld()
gfx_config.screen_width = 160
gfx_config.screen_height = 120
gfx_config.render_window = True
pystk.clean()
pystk.init(gfx_config)
# Current action space is only steering left/right
#self.action_space = gym.spaces.Tuple([gym.spaces.Box(low=-1.0, high=1.0, shape=(1,)), gym.spaces.Discrete(2)])
self.action_space = gym.spaces.Box(np.array(
[-1, 0, 0, 0]), np.array([1, 1, 1, 1])) # steer, gas, brake, fire
self.observation_space = gym.spaces.Box(low=0.0,
high=1.0,
shape=(120, 160, 3))
self.race = None
self.max_step = 4000
self.curr_iter = 0
self.prev_distance = 0
def __init__(self, track: str):
config = pystk.GraphicsConfig.ld()
config.screen_width = 64
config.screen_height = 64
config.render_window = False
pystk.init(config)
race_config = pystk.RaceConfig()
race_config.num_kart = 4
race_config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[0].team = 0
race_config.players[
1].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[1].team = 0
race_config.players[
2].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[2].team = 1
race_config.players[
3].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[2].team = 1
race_config.track = track
race_config.step_size = 0.1
race_config.render = False
race_config.mode = race_config.RaceMode.THREE_STRIKES
self.race = pystk.Race(race_config)
self.race.start()
self.race.step()
self.track = pystk.Track()
self.track.update()
parser.add_argument('--team', type=int, default=0, choices=[0, 1])
parser.add_argument('-s', '--step_size', type=float)
parser.add_argument('-n', '--num_player', type=int, default=1)
parser.add_argument('-v', '--visualization', type=str, choices=list(gui.VT.__members__), nargs='+',
default=['IMAGE'])
parser.add_argument('--verbose', action='store_true')
parser.add_argument('--save_dir', type=Path, required=False)
args = parser.parse_args()
if args.save_dir:
args.save_dir.mkdir(parents=True, exist_ok=True)
config = pystk.GraphicsConfig.hd()
config.screen_width = 400
config.screen_height = 300
pystk.init(config)
config = pystk.RaceConfig()
config.num_kart = 2
if args.kart is not None:
config.players[0].kart = args.kart
config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.players[0].team = args.team
for i in range(1, args.num_player):
config.players.append(
pystk.PlayerConfig(args.kart, pystk.PlayerConfig.Controller.AI_CONTROL, (args.team + 1) % 2))
if args.track is not None:
config.track = args.track
from .grader import Grader, Case, MultiCase
import numpy as np
import torchvision.transforms.functional as TF
from os import path
import torch
import pystk
RESCUE_TIMEOUT = 30
TRACK_OFFSET = 15
pystk_config = pystk.GraphicsConfig.hd()
pystk_config.screen_width = 128
pystk_config.screen_height = 96
pystk.init(pystk_config)
class PySTKGrader(Grader):
use_planner = False
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.C = self.module.control
self.P = None
if self.use_planner:
self.P = self.module.load_model().eval()
@staticmethod
def _point_on_track(distance, track, offset=0.0):
"""
def train(args):
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
print('Device:', device)
model = Action(normalize=True, inference=False).to(device)
model.train(True)
vision_model = load_vision_model('vision') #Vision().to(device)
vision_model.to(device)
vision_model.train(False)
vision_model.eval()
loss = torch.nn.L1Loss()
loss.requires_grad = True
optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
batch_size = args.batch_size
max_steps = args.max_steps
num_players = 1
if args.logdir is not None:
train_logger = tb.SummaryWriter(log_dir=os.path.join(
args.logdir, 'train_{}'.format(args.log_suffix)),
flush_secs=1)
#PySTK init
config = pystk.GraphicsConfig.hd()
config.screen_width = 400
config.screen_height = 300
pystk.init(config)
train_data = list(
itertools.chain(
*[rollout(device, vision_model, model) for it in range(10)]))
global_step = 0
for e in range(args.epochs):
all_targets = []
all_predictions = []
# state = pystk.WorldState()
# print('a')
if e > 1:
train_data.extend(rollout_agent(device, vision_model, model))
np.random.shuffle(train_data)
# print(train_data)
for iteration in range(0,
len(train_data) - batch_size + 1, batch_size):
# print('\rEpoch: {} Step: {} of {}'.format(e,iteration//batch_size,batch_size), end='\r')
print(iteration)
batch_data = torch.as_tensor([
train_data[i][0]
for i in range(iteration, iteration + batch_size)
]).permute(0, 3, 1, 2).float()
batch_label = torch.as_tensor([
train_data[i][1]
for i in range(iteration, iteration + batch_size)
]).float()
# heatmap = vision_model(batch_data.to(device))
# p = model(torch.sigmoid(heatmap))
p = model(batch_data.to(device))
samples = []
log_probs = []
for row in p:
steer_dist = Normal(
row[0],
torch.abs(row[1]) +
0.001) #make sure sigma is positive and non-zero
acc_dist = Normal(
row[2],
torch.abs(row[3]) +
0.001) #make sure sigma is positive and non-zero
brake_dist = Normal(
row[4],
torch.abs(row[5]) +
0.001) #make sure sigma is positive and non-zero
steer = steer_dist.sample()
acc = acc_dist.sample()
brake = brake_dist.sample()
s = torch.tensor([steer, acc, brake],
dtype=torch.float,
requires_grad=True)
samples.append(s)
lp = torch.tensor([
-steer_dist.log_prob(steer), -acc_dist.log_prob(acc),
-brake_dist.log_prob(brake)
],
requires_grad=True)
log_probs.append(lp)
samples = torch.stack(samples)
log_probs = torch.stack(log_probs)
# print(samples)
# print(batch_label.to(device))
# print(log_probs)
# l = loss(samples, batch_label.to(device))
# print(torch.abs(samples - batch_label.to(device)))
# input()
l = (log_probs.cpu() *
torch.abs(samples.cpu() - batch_label.cpu())).sum()
print(l)
optimizer.zero_grad()
l.backward()
optimizer.step()
all_targets.append(batch_label.detach().cpu().numpy())
all_predictions.append(p.squeeze().detach().cpu().numpy())
if args.logdir is not None:
train_logger.add_scalar('loss',
l.cpu(),
global_step=global_step)
global_step += 1
# if args.logdir is not None:
# train_logger.add_scalar('RMSE_steer', getRMSE(all_predictions, all_targets, 0),global_step=e)
# train_logger.add_scalar('RMSE_acceleration', getRMSE(all_predictions, all_targets, 1),global_step=e)
# train_logger.add_scalar('RMSE_brake', getRMSE(all_predictions, all_targets, 2),global_step=e)
save_model(model, 'action')
import pystk
pystk.init(pystk.GraphicsConfig.ld())
karts = pystk.list_karts()
pystk.clean()
print('List of karts [%d]:' % len(karts))
for l in karts:
print(' * \'%s\'' % l)
print()
def _config_race(self):
g_config = pystk.GraphicsConfig.hd()
g_config.screen_width = 160
g_config.screen_height = 120
pystk.init(g_config)
def _config_race(self):
g_config = pystk.GraphicsConfig.ld()
g_config.screen_width = 128
g_config.screen_height = 96
pystk.init(g_config)
