l1 = batch[3].to(device)
r = batch[4]
else:
l0 = l1 = None
r = batch[2]
pred, loss = m(x0, x1, l0, l1)
y_pred += torch.max(pred, dim=1)[1].detach().cpu().numpy().tolist()
y_true += r.detach().cpu().numpy().tolist()
acc = accuracy_score(y_true, y_pred) * 100
#f1 = f1_score(y_true, y_pred) * 100
report = classification_report(y_true, y_pred)
return acc, report
for epoch_index in range(epoch_num):
model.train()
epoch_loss = 0.
time_now = time()
#for batch in tqdm(train_dataloader):
for batch in train_dataloader:
optimizer.zero_grad()
x0 = batch[0].to(device)
x1 = batch[1].to(device)
if model.embedding_type == "word":
l0 = batch[2].to(device)
l1 = batch[3].to(device)
r = batch[4].to(device)
else:
l0 = l1 = None
r = batch[2].to(device)
pred, loss = model(x0, x1, l0, l1, r)
class Driver(object):
'''
A driver object for the SCRC
'''
def __init__(self, args):
'''Constructor'''
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.state_size = 20
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size, self.action_size)
self.enable_training = args.enable_training
self.enable_exploration = args.enable_exploration
self.show_sensors = args.show_sensors
self.exploration_decay_steps = args.exploration_decay_steps
self.exploration_rate_start = args.exploration_rate_start
self.exploration_rate_end = args.exploration_rate_end
from wheel import Wheel
self.wheel = Wheel(args.joystick_nr, args.autocenter, args.gain, args.min_level, args.max_level, args.min_force)
self.steer_lock = 0.785398
self.max_speed = 100
#from plotlinear import PlotLinear
#self.plot = PlotLinear(self.model, ['Speed', 'Angle', 'TrackPos'], ['Steer', 'Accel', 'Brake'])
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
self.reset()
def init(self):
'''Return init string with rangefinder angles'''
self.angles = [0 for x in range(19)]
for i in range(5):
self.angles[i] = -90 + i * 15
self.angles[18 - i] = 90 - i * 15
for i in range(5, 9):
self.angles[i] = -20 + (i-5) * 5
self.angles[18 - i] = 20 - (i-5) * 5
return self.parser.stringify({'init': self.angles})
def getState(self):
#state = np.array(self.state.getTrack())
state = np.array(self.state.getTrack() + [self.state.getSpeedX()])
assert state.shape == (self.state_size,)
return state
def getTerminal(self):
return np.all(np.array(self.state.getTrack()) == -1)
def getEpsilon(self):
# calculate decaying exploration rate
if self.total_train_steps < self.exploration_decay_steps:
return self.exploration_rate_start - self.total_train_steps * (self.exploration_rate_start - self.exploration_rate_end) / self.exploration_decay_steps
else:
return self.exploration_rate_end
def drive(self, msg):
# parse incoming message
self.state.setFromMsg(msg)
# by default predict all controls by model
state = self.getState()
steer, accel, brake = self.model.predict(state)
self.control.setSteer(max(-1, min(1, steer)))
self.control.setAccel(max(0, min(1, accel)))
#self.control.setBrake(max(0, min(1, brake)))
# if not out of track turn the wheel according to model
terminal = self.getTerminal()
events = self.wheel.getEvents()
for event in events:
if self.wheel.isButtonDown(event, 0) or self.wheel.isButtonDown(event, 8):
self.control.setGear(-1)
elif self.wheel.isButtonDown(event, 1) or self.wheel.isButtonDown(event, 9):
self.control.setGear(1)
if self.control.getGear() >= 0:
self.gear()
# replace random exploration with user assistance
epsilon = self.getEpsilon()
# show sensors
if self.show_sensors:
self.state.botcontrol = 1 - epsilon
self.state.mancontrol = (self.control.getGear() == -1)
self.stats.update(self.state)
print "epsilon: ", epsilon, "\treplay: ", self.model.count
if (self.enable_training and terminal) or self.control.getGear() == -1 or (self.enable_exploration and random.random() < epsilon):
if terminal or self.control.getGear() == -1:
self.wheel.resetForce()
self.control.setSteer(self.wheel.getWheel())
self.control.setAccel(self.wheel.getAccel())
self.control.setBrake(self.wheel.getBrake())
if self.enable_training and not terminal and self.control.getGear() != -1:
action = (self.control.getSteer(), self.control.getAccel(), self.control.getBrake())
self.model.add(state, action)
self.model.train()
#self.plot.update()
else:
if terminal:
self.steer()
self.speed()
else:
steer = self.control.getSteer()
assert -1 <= steer <= 1
wheel = self.wheel.getWheel()
#print "steer:", steer, "wheel:", wheel
self.wheel.generateForce(steer - wheel)
self.total_train_steps += 1
return self.control.toMsg()
def steer(self):
angle = self.state.angle
dist = self.state.trackPos
self.control.setSteer((angle - dist*0.5)/self.steer_lock)
def speed(self):
speed = self.state.getSpeedX()
accel = self.control.getAccel()
if speed < self.max_speed:
print "speed < max_speed", speed, self.max_speed
accel += 0.1
if accel > 1:
accel = 1.0
else:
print "speed >= max_speed", speed, self.max_speed
accel -= 0.1
if accel < 0:
accel = 0.0
self.control.setAccel(accel)
def gear(self):
'''
rpm = self.state.getRpm()
gear = self.state.getGear()
if rpm > 7000:
gear += 1
'''
speed = self.state.getSpeedX()
gear = self.state.getGear()
if speed < 25:
gear = 1
elif 30 < speed < 55:
gear = 2
elif 60 < speed < 85:
gear = 3
elif 90 < speed < 115:
gear = 4
elif 120 < speed < 145:
gear = 5
elif speed > 150:
gear = 6
self.control.setGear(gear)
def onShutDown(self):
pass
def onRestart(self):
self.episode += 1
print "Episode", self.episode
def reset(self):
self.wheel.resetForce()
self.enable_training = True
self.total_train_steps = 0
self.model.reset()
self.episode = 0
self.onRestart()
def test_mode(self):
self.total_train_steps = self.exploration_decay_steps
self.enable_training = False
class Driver(object):
'''
A driver object for the SCRC
'''
def __init__(self, args):
'''Constructor'''
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.state_size = 20
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size,
self.action_size)
self.enable_training = args.enable_training
self.enable_exploration = args.enable_exploration
self.show_sensors = args.show_sensors
self.exploration_decay_steps = args.exploration_decay_steps
self.exploration_rate_start = args.exploration_rate_start
self.exploration_rate_end = args.exploration_rate_end
from wheel import Wheel
self.wheel = Wheel(args.joystick_nr, args.autocenter, args.gain,
args.min_level, args.max_level, args.min_force)
self.steer_lock = 0.785398
self.max_speed = 100
#from plotlinear import PlotLinear
#self.plot = PlotLinear(self.model, ['Speed', 'Angle', 'TrackPos'], ['Steer', 'Accel', 'Brake'])
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
self.reset()
def init(self):
'''Return init string with rangefinder angles'''
self.angles = [0 for x in range(19)]
for i in range(5):
self.angles[i] = -90 + i * 15
self.angles[18 - i] = 90 - i * 15
for i in range(5, 9):
self.angles[i] = -20 + (i - 5) * 5
self.angles[18 - i] = 20 - (i - 5) * 5
return self.parser.stringify({'init': self.angles})
def getState(self):
#state = np.array(self.state.getTrack())
state = np.array(self.state.getTrack() + [self.state.getSpeedX()])
assert state.shape == (self.state_size, )
return state
def getTerminal(self):
return np.all(np.array(self.state.getTrack()) == -1)
def getEpsilon(self):
# calculate decaying exploration rate
if self.total_train_steps < self.exploration_decay_steps:
return self.exploration_rate_start - self.total_train_steps * (
self.exploration_rate_start -
self.exploration_rate_end) / self.exploration_decay_steps
else:
return self.exploration_rate_end
def drive(self, msg):
# parse incoming message
self.state.setFromMsg(msg)
# by default predict all controls by model
state = self.getState()
steer, accel, brake = self.model.predict(state)
self.control.setSteer(max(-1, min(1, steer)))
self.control.setAccel(max(0, min(1, accel)))
#self.control.setBrake(max(0, min(1, brake)))
# if not out of track turn the wheel according to model
terminal = self.getTerminal()
events = self.wheel.getEvents()
for event in events:
if self.wheel.isButtonDown(event, 0) or self.wheel.isButtonDown(
event, 8):
self.control.setGear(-1)
elif self.wheel.isButtonDown(event, 1) or self.wheel.isButtonDown(
event, 9):
self.control.setGear(1)
if self.control.getGear() >= 0:
self.gear()
# replace random exploration with user assistance
epsilon = self.getEpsilon()
# show sensors
if self.show_sensors:
self.state.botcontrol = 1 - epsilon
self.state.mancontrol = (self.control.getGear() == -1)
self.stats.update(self.state)
print "epsilon: ", epsilon, "\treplay: ", self.model.count
if (self.enable_training
and terminal) or self.control.getGear() == -1 or (
self.enable_exploration and random.random() < epsilon):
if terminal or self.control.getGear() == -1:
self.wheel.resetForce()
self.control.setSteer(self.wheel.getWheel())
self.control.setAccel(self.wheel.getAccel())
self.control.setBrake(self.wheel.getBrake())
if self.enable_training and not terminal and self.control.getGear(
) != -1:
action = (self.control.getSteer(), self.control.getAccel(),
self.control.getBrake())
self.model.add(state, action)
self.model.train()
#self.plot.update()
else:
if terminal:
self.steer()
self.speed()
else:
steer = self.control.getSteer()
assert -1 <= steer <= 1
wheel = self.wheel.getWheel()
#print "steer:", steer, "wheel:", wheel
self.wheel.generateForce(steer - wheel)
self.total_train_steps += 1
return self.control.toMsg()
def steer(self):
angle = self.state.angle
dist = self.state.trackPos
self.control.setSteer((angle - dist * 0.5) / self.steer_lock)
def speed(self):
speed = self.state.getSpeedX()
accel = self.control.getAccel()
if speed < self.max_speed:
print "speed < max_speed", speed, self.max_speed
accel += 0.1
if accel > 1:
accel = 1.0
else:
print "speed >= max_speed", speed, self.max_speed
accel -= 0.1
if accel < 0:
accel = 0.0
self.control.setAccel(accel)
def gear(self):
'''
rpm = self.state.getRpm()
gear = self.state.getGear()
if rpm > 7000:
gear += 1
'''
speed = self.state.getSpeedX()
gear = self.state.getGear()
if speed < 25:
gear = 1
elif 30 < speed < 55:
gear = 2
elif 60 < speed < 85:
gear = 3
elif 90 < speed < 115:
gear = 4
elif 120 < speed < 145:
gear = 5
elif speed > 150:
gear = 6
self.control.setGear(gear)
def onShutDown(self):
pass
def onRestart(self):
self.episode += 1
print "Episode", self.episode
def reset(self):
self.wheel.resetForce()
self.enable_training = True
self.total_train_steps = 0
self.model.reset()
self.episode = 0
self.onRestart()
def test_mode(self):
self.total_train_steps = self.exploration_decay_steps
self.enable_training = False
def hybrid_linear_training(threshold, stage_nums, train_data_x, train_data_y,
test_data_x, test_data_y, model):
stage_length = len(stage_nums)
col_num = stage_nums[1]
tmp_inputs = [[[] for i in range(col_num)] for i in range(stage_length)]
tmp_labels = [[[] for i in range(col_num)] for i in range(stage_length)]
index = [[None for i in range(col_num)] for i in range(stage_length)]
tmp_inputs[0][0] = train_data_x
tmp_labels[0][0] = train_data_y
test_inputs = test_data_x
for i in range(0, stage_length):
for j in range(0, stage_nums[i]):
if len(tmp_labels[i][j]) == 0:
continue
inputs = tmp_inputs[i][j]
labels = []
test_labels = []
if i == 0:
# first stage, calculate how many models in next stage
divisor = stage_nums[i + 1] * 1.0 / (TOTAL_NUMBER / BLOCK_SIZE)
for k in tmp_labels[i][j]:
labels.append(int(k * divisor))
for k in test_data_y:
test_labels.append(int(k * divisor))
else:
labels = tmp_labels[i][j]
test_labels = test_data_y
# train model
if model == "linear":
tmp_index = LinearModel(LinearRegression(), inputs, labels)
elif model == "logistic":
tmp_index = LinearModel(LogisticRegression(), inputs, labels)
tmp_index.train()
tmp_index.set_error(inputs, labels)
# get parameters in model (weight matrix and bias matrix)
index[i][j] = tmp_index
del tmp_index
gc.collect()
if i < stage_length - 1:
# allocate data into training set for models in next stage
for ind in range(len(tmp_inputs[i][j])):
# pick model in next stage with output of this model
p = index[i][j].predict(tmp_inputs[i][j][ind])
if p > stage_nums[i + 1] - 1:
p = stage_nums[i + 1] - 1
# print(p)
tmp_inputs[i + 1][p].append(tmp_inputs[i][j][ind])
tmp_labels[i + 1][p].append(tmp_labels[i][j][ind])
for i in range(stage_nums[stage_length - 1]):
if index[stage_length - 1][i] is None:
continue
mean_abs_err = index[stage_length - 1][i].mean_err
if mean_abs_err > threshold[stage_length - 1]:
# replace model with BTree if mean error > threshold
print("Using BTree")
index[stage_length - 1][i] = BTree(32)
index[stage_length - 1][i].build(tmp_inputs[stage_length - 1][i],
tmp_labels[stage_length - 1][i])
return index
class Driver(object):
'''
A driver object for the SCRC
'''
def __init__(self, args):
'''Constructor'''
self.WARM_UP = 0
self.QUALIFYING = 1
self.RACE = 2
self.UNKNOWN = 3
self.stage = args.stage
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.state_size = 3
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size,
self.action_size)
self.steer_lock = 0.785398
self.max_speed = 100
self.enable_training = args.enable_training
self.enable_exploration = args.enable_exploration
self.show_sensors = args.show_sensors
self.total_train_steps = 0
self.exploration_decay_steps = args.exploration_decay_steps
self.exploration_rate_start = args.exploration_rate_start
self.exploration_rate_end = args.exploration_rate_end
self.episode = 0
self.onRestart()
#from plotlinear import PlotLinear
#self.plot = PlotLinear(self.model, ['Speed', 'Angle', 'TrackPos'], ['Steer', 'Accel', 'Brake'])
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
def init(self):
'''Return init string with rangefinder angles'''
self.angles = [0 for x in range(19)]
for i in range(5):
self.angles[i] = -90 + i * 15
self.angles[18 - i] = 90 - i * 15
for i in range(5, 9):
self.angles[i] = -20 + (i - 5) * 5
self.angles[18 - i] = 20 - (i - 5) * 5
return self.parser.stringify({'init': self.angles})
def getState(self):
state = np.array([
self.state.getSpeedX(),
self.state.getAngle(),
self.state.getTrackPos()
])
assert state.shape == (self.state_size, )
return state
def getTerminal(self):
return np.all(np.array(self.state.getTrack()) == -1)
def getEpsilon(self):
# calculate decaying exploration rate
if self.total_train_steps < self.exploration_decay_steps:
return self.exploration_rate_start - self.total_train_steps * (
self.exploration_rate_start -
self.exploration_rate_end) / self.exploration_decay_steps
else:
return self.exploration_rate_end
def drive(self, msg):
# parse incoming message
self.state.setFromMsg(msg)
# show sensors
if self.show_sensors:
self.stats.update(self.state)
# during exploration use hard-coded algorithm
state = self.getState()
terminal = self.getTerminal()
epsilon = self.getEpsilon()
print "epsilon: ", epsilon, "\treplay: ", self.model.count
if terminal or (self.enable_exploration and random.random() < epsilon):
self.steer()
self.speed()
self.gear()
if self.enable_training:
action = (self.control.getSteer(), self.control.getAccel(),
self.control.getBrake())
self.model.add(state, action)
self.model.train()
#self.plot.update()
else:
steer, accel, brake = self.model.predict(state)
#print "steer:", steer, "accel:", accel, "brake:", brake
self.control.setSteer(steer)
self.control.setAccel(accel)
self.control.setBrake(brake)
self.gear()
self.total_train_steps += 1
return self.control.toMsg()
def steer(self):
angle = self.state.angle
dist = self.state.trackPos
self.control.setSteer((angle - dist * 0.5) / self.steer_lock)
def gear(self):
rpm = self.state.getRpm()
gear = self.state.getGear()
if self.prev_rpm == None:
up = True
else:
if (self.prev_rpm - rpm) < 0:
up = True
else:
up = False
if up and rpm > 7000:
gear += 1
if not up and rpm < 3000:
gear -= 1
'''
speed = self.state.getSpeedX()
if speed < 30:
gear = 1
elif speed < 60:
gear = 2
elif speed < 90:
gear = 3
elif speed < 120:
gear = 4
elif speed < 150:
gear = 5
else:
gear = 6
'''
self.control.setGear(gear)
def speed(self):
speed = self.state.getSpeedX()
accel = self.control.getAccel()
if speed < self.max_speed:
accel += 0.1
if accel > 1:
accel = 1.0
else:
accel -= 0.1
if accel < 0:
accel = 0.0
self.control.setAccel(accel)
def onShutDown(self):
pass
def onRestart(self):
self.prev_rpm = None
self.episode += 1
print "Episode", self.episode
class Driver(object):
'''
A driver object for the SCRC
'''
def __init__(self, args):
'''Constructor'''
self.WARM_UP = 0
self.QUALIFYING = 1
self.RACE = 2
self.UNKNOWN = 3
self.stage = args.stage
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.state_size = 3
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size, self.action_size)
self.steer_lock = 0.785398
self.max_speed = 100
self.enable_training = args.enable_training
self.enable_exploration = args.enable_exploration
self.show_sensors = args.show_sensors
self.total_train_steps = 0
self.exploration_decay_steps = args.exploration_decay_steps
self.exploration_rate_start = args.exploration_rate_start
self.exploration_rate_end = args.exploration_rate_end
self.episode = 0
self.onRestart()
#from plotlinear import PlotLinear
#self.plot = PlotLinear(self.model, ['Speed', 'Angle', 'TrackPos'], ['Steer', 'Accel', 'Brake'])
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
def init(self):
'''Return init string with rangefinder angles'''
self.angles = [0 for x in range(19)]
for i in range(5):
self.angles[i] = -90 + i * 15
self.angles[18 - i] = 90 - i * 15
for i in range(5, 9):
self.angles[i] = -20 + (i-5) * 5
self.angles[18 - i] = 20 - (i-5) * 5
return self.parser.stringify({'init': self.angles})
def getState(self):
state = np.array([self.state.getSpeedX(), self.state.getAngle(), self.state.getTrackPos()])
assert state.shape == (self.state_size,)
return state
def getTerminal(self):
return np.all(np.array(self.state.getTrack()) == -1)
def getEpsilon(self):
# calculate decaying exploration rate
if self.total_train_steps < self.exploration_decay_steps:
return self.exploration_rate_start - self.total_train_steps * (self.exploration_rate_start - self.exploration_rate_end) / self.exploration_decay_steps
else:
return self.exploration_rate_end
def drive(self, msg):
# parse incoming message
self.state.setFromMsg(msg)
# show sensors
if self.show_sensors:
self.stats.update(self.state)
# during exploration use hard-coded algorithm
state = self.getState()
terminal = self.getTerminal()
epsilon = self.getEpsilon()
print "epsilon: ", epsilon, "\treplay: ", self.model.count
if terminal or (self.enable_exploration and random.random() < epsilon):
self.steer()
self.speed()
self.gear()
if self.enable_training:
action = (self.control.getSteer(), self.control.getAccel(), self.control.getBrake())
self.model.add(state, action)
self.model.train()
#self.plot.update()
else:
steer, accel, brake = self.model.predict(state)
#print "steer:", steer, "accel:", accel, "brake:", brake
self.control.setSteer(steer)
self.control.setAccel(accel)
self.control.setBrake(brake)
self.gear()
self.total_train_steps += 1
return self.control.toMsg()
def steer(self):
angle = self.state.angle
dist = self.state.trackPos
self.control.setSteer((angle - dist*0.5)/self.steer_lock)
def gear(self):
rpm = self.state.getRpm()
gear = self.state.getGear()
if self.prev_rpm == None:
up = True
else:
if (self.prev_rpm - rpm) < 0:
up = True
else:
up = False
if up and rpm > 7000:
gear += 1
if not up and rpm < 3000:
gear -= 1
'''
speed = self.state.getSpeedX()
if speed < 30:
gear = 1
elif speed < 60:
gear = 2
elif speed < 90:
gear = 3
elif speed < 120:
gear = 4
elif speed < 150:
gear = 5
else:
gear = 6
'''
self.control.setGear(gear)
def speed(self):
speed = self.state.getSpeedX()
accel = self.control.getAccel()
if speed < self.max_speed:
accel += 0.1
if accel > 1:
accel = 1.0
else:
accel -= 0.1
if accel < 0:
accel = 0.0
self.control.setAccel(accel)
def onShutDown(self):
pass
def onRestart(self):
self.prev_rpm = None
self.episode += 1
print "Episode", self.episode
