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, conf_file):
LinearModel.__init__(self, conf_file)
if 'train_data' in self.conf.options('logistic_regression'):
self._load_data(self.conf.get('logistic_regression', 'train_data'))
self.alpha = self.conf.getfloat('logistic_regression', 'alpha')
self.iters = self.conf.getint('logistic_regression', 'num_iters')
self.lambd = self.conf.getfloat('logistic_regression', 'lambda')
self.intercept = self.conf.getboolean('linear_regression', 'has_intercept')
def init_model_3d(self, params):
# device_cout = {"GPU": 1}
# with tf.Session(config=tf.ConfigProto(
# device_count=device_count,
# allow_soft_placement=True )) as sess:
self.sess = tf.Session()
summaries_dir = os.path.join( params['train_dir'], params['summaries_dir'] )
self.linearModel = LinearModel(params['linear_size'], params['num_layers'], params['residual'], params['batch_norm'], \
params['max_norm'], params['batch_size'], params['learning_rate'], summaries_dir, params['use_root'], dtype=tf.float32)
self.linearModel.train_writer.add_graph( self.sess.graph)
class TestRMSprop(TestCase):
def setUp(self):
self.optimizer = RMSprop(0.1)
self.model = LinearModel(self.optimizer)
def test_linear_model_cpu(self):
self.assertGreater(self.model.accuracy(False), 0.7)
@attr.gpu
def test_linear_model_gpu(self):
self.assertGreater(self.model.accuracy(True), 0.7)
class TestRMSprop(TestCase):
def setUp(self):
self.optimizer = RMSprop(0.1)
self.model = LinearModel(self.optimizer)
def test_linear_model_cpu(self):
self.assertGreater(self.model.accuracy(False), 0.7)
@attr.gpu
def test_linear_model_gpu(self):
self.assertGreater(self.model.accuracy(True), 0.7)
class TestAdaDelta(TestCase):
def setUp(self):
self.optimizer = AdaDelta(eps=1e-5)
self.model = LinearModel(self.optimizer)
def test_linear_model_cpu(self):
self.assertGreater(self.model.accuracy(False), 0.7)
@attr.gpu
def test_linear_model_gpu(self):
self.assertGreater(self.model.accuracy(True), 0.7)
class TestAdaDelta(TestCase):
def setUp(self):
self.optimizer = AdaDelta(eps=1e-5)
self.model = LinearModel(self.optimizer)
def test_linear_model_cpu(self):
self.assertGreater(self.model.accuracy(False), 0.75)
@attr.gpu
def test_linear_model_gpu(self):
self.assertGreater(self.model.accuracy(True), 0.75)
class TestMomentumSGD(TestCase):
def setUp(self):
self.optimizer = MomentumSGD(0.1)
self.model = LinearModel(self.optimizer)
def test_linear_model_cpu(self):
self.assertGreater(self.model.accuracy(False), 0.8)
@attr.gpu
def test_linear_model_gpu(self):
self.assertGreater(self.model.accuracy(True), 0.8)
def test_single_column_input(self):
torch.manual_seed(24637882)
dataset_size = 8000
test_dataset_size = 1000
data_columns = 6
competitors = 8
dataset_generator = ArtificialDataset(dataset_size,
competitors,
data_columns,
rand_eps=1e-3)
loader_iterator = iter(DataLoader(dataset_generator))
linear_model = LinearModel(data_columns,
1) # number of columns to score
optimizer = torch.optim.Adam(params=linear_model.parameters())
loss = ExplodedLogitLoss(loss_type='nll', top_n=3)
for step in range(dataset_size):
data, order = next(loader_iterator)
optimizer.zero_grad()
score = linear_model(data).squeeze(-1)
loss_value = loss(score, order)
loss_value.backward()
optimizer.step()
if step % 1000 == 0:
print("Loss value: {0}".format(loss_value.item()))
with torch.no_grad():
for _ in range(test_dataset_size):
data, expected_order = next(loader_iterator)
score = linear_model(data).squeeze(-1)
actual_order = get_sort_order(score)
self.assertTrue(
torch.equal(actual_order, expected_order),
"Order not equal:\n{0}\n{1}".format(
actual_order, expected_order))
print("\n\nLinear transformation weights matrix\n--------------------")
print(linear_model.linear.weight)
print("Linear transformation bias:")
print(linear_model.linear.bias)
print("\n\nOriginal coefficients\n--------------------")
print(dataset_generator.coeffs[0])
print("Original bias")
print(dataset_generator.biases[0])
def __init__(self, options):
LinearModel.__init__(self)
self.alpha = options.alpha
self.iters = options.num_iters
self.lambd = options.lambd
self.intercept = options.has_intercept
self.model_in = options.model_in
self.model_out = options.model_out
self.training_file = options.training_file
self.test_file = options.test_file
self.results_file = options.results_file
if self.test_file != '':
self._load_data(self.test_file)
else:
self._load_data(self.training_file)
def main(args):
# Load data
loader = getattr(datasets, '_'.join(['load', args.dataset, 'data']))
X_train, X_test, y_train, y_test = loader(file_path=args.data_fp)
# Logistic Regression models
lr_models = {}
for solver in {
'gd', 'sgd', 'saga', 'svrg', 'nm', 'bfgs', 'lbfgs', 'slbfgs'
}:
lr_models[solver] = LinearModel(loss_fn='logistic', solver=solver)
for solver, model in lr_models.items():
fit_kwargs = {'max_iter': args.epochs, 'smoothness': 1.0}
if solver in {'saga', 'svrg'}:
fit_kwargs['strong_convexity'] = args.sconv
elif solver == 'slbfgs':
fit_kwargs['n_updates'] = 10
fit_kwargs['memory_size'] = 10
fit_kwargs['n_curve_updates'] = 10
fit_kwargs['batch_size_grad'] = 32
fit_kwargs['batch_size_hess'] = 32
print(f'fitting {solver}\n')
model.fit(X_train, y_train, **fit_kwargs)
learning_curve(**lr_models)
def predict(self, X, results_file):
ret = LinearModel.predict(self, X)
pred = self._sigmoid(ret)
fp = open(results_file, 'w')
for v in pred.flat:
print >> fp, v
fp.close()
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 test_gym():
"""
- remove the 200 steps force
- deduce episodes from 500 to 100
"""
env = gym.make('MountainCar-v0').env
linear_func = LinearModel(feat_n, get_feature)
agent = QLearnAgent(act_n=3, linear_func=linear_func)
rs = gym_demo(env, agent, 100)
plt.plot(range(100), rs), plt.grid(), plt.show()
def main():
# Build parser
parser = build_parser()
options = parser.parse_args()
# Set random seed
random.seed(options.random_seed)
# Get CEM methods
cem = CrossEntropyMethod(N=options.n, p=options.p)
# Create environment object
env = CartPoleEnv()
# Create linear model
model = LinearModel(dims=env.obs_dim())
# Initialize parameters
params = model.params
# Episode scores
win_ratio_list = []
successful_episodes = 0
for i_episode in range(options.episodes):
sys.stderr.write('\n###### Episode {} of {} ###### \n'.format(i_episode+1, options.episodes))
# Sample N parameter vectors
noisy_params = cem.sample_parameters(params)
# Evaluate the sampled vectors
rewards = [noisy_evaluation(model, env, options.step_size, i) for i in noisy_params]
# Get elite parameters based on reward
elite_params = cem.get_elite_parameters(noisy_params,rewards)
# Update parameters
params = cem.get_parameter_mean(elite_params)
episode_reward = run_episode(model=update_model(model,params), env=env, steps=options.step_size, print_step=options.print_step)
win_ratio = episode_reward / options.step_size
sys.stderr.write('Episode reward: {} ({:.2f}%)\n'.format(episode_reward, win_ratio))
# Save win_ratio
win_ratio_list.append(win_ratio)
if episode_reward >= options.step_size:
successful_episodes += 1
sys.stderr.write('\nFinal params: {}'.format(model.params))
sys.stderr.write('\nRun finished. {} out of {} episodes ({:.2f}%) have a reward of atleast {}\n'.format(successful_episodes, options.episodes, successful_episodes / options.episodes, options.step_size))
# If output_file is given, write scores to disk
if options.output_file:
sys.stderr.write('\nWriting scores to file: {}.csv...\n'.format(options.output_file))
with open(options.output_file + '.csv', 'w', newline='') as f:
wr = csv.writer(f)
wr.writerow(win_ratio_list)
sys.stderr.write('Done!\n')
# Terminate the host program
env.terminate()
def __init__(self, args):
'''Constructor'''
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
assert args.load_weights is not None, "Use --load_weights"
self.state_fields = args.state_fields
self.state_size = len(self.state_fields)
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size, self.action_size)
self.model.load(args.load_weights)
self.episode = 0
self.onRestart()
self.show_sensors = args.show_sensors
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
class TestLinearModel(unittest.TestCase):
def setUp(self):
self.regular_obs_dim = 4
self.model_ = LinearModel(1)
self.model_.params = [5]
def test_dims_input(self):
"""Check if error is raised when initializing the class with wrong type"""
with self.assertRaises(TypeError):
model = LinearModel(312.34)
def test_params_length(self):
"""Check if length of params attribute equals to dims vector"""
obs_dim = random.randint(1,10)
model = LinearModel(obs_dim)
self.assertEqual(len(model.params), obs_dim)
def test_action_input(self):
"""Check if error is raised when length of params and obs are not the same"""
new_obs = [random.uniform(-1,1) for i in range(random.randint(5,10))]
model = LinearModel(self.regular_obs_dim)
with self.assertRaises(AssertionError):
model.action(new_obs)
def test_return_sign_positive(self):
"""Check if the sign returned is as expected given the input"""
pos_obs = [random.uniform(1,2)]
self.assertEqual(self.model_.action(pos_obs),1)
def test_return_sign_negative(self):
"""Check if the sign returned is as expected given the input"""
neg_obs = [random.uniform(-2,-1)]
self.assertEqual(self.model_.action(neg_obs),-1)
def test_return_sign_negative_for_zero(self):
"""Check if the sign returned is as expected given the input"""
zero_obs = [0]
self.assertEqual(self.model_.action(zero_obs),-1)
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 main():
print("main started")
samples, labels = load_trainingset()
# Build a model using a class, and after the compilation we'll start the training
model = LinearModel("my_model")
model.compile_model()
model.training(samples, labels)
# Evaluate a sample using the model
print(model.predict([30.0]))
print("main finish")
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)
test_dataset = TensorDataset(test_input_0, test_input_1, test_y)
else:
train_length_0 = torch.LongTensor(train_length_0)
train_length_1 = torch.LongTensor(train_length_1)
test_length_0 = torch.LongTensor(test_length_0)
test_length_1 = torch.LongTensor(test_length_1)
train_dataset = TensorDataset(train_input_0, train_input_1, train_length_0, train_length_1, train_y)
test_dataset = TensorDataset(test_input_0, test_input_1, test_length_0, test_length_1, test_y)
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=1)
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=1)
# Prepare model and optimizier
# model
if embedding_type != 'bert':
use_embedding = torch.FloatTensor(use_embedding)
model = LinearModel(len(rel2id), embedding_type, use_embedding, freeze_embedding).to(device)
else:
try:
config = AutoConfig.from_pretrained(embedding)
bert_model = AutoModel.from_pretrained(embedding, config=config).to(device)
except BaseException:
bert_model = torch.load(os.path.join(embedding, 'pytorch_model.bin')).to(device)
model = LinearModel(len(rel2id), embedding_type, bert_model, freeze_embedding).to(device)
# optimizier
if embedding_type != 'bert':
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
if embedding_type == "bert":
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [
{
def setUp(self):
self.optimizer = RMSprop(0.1)
self.model = LinearModel(self.optimizer)
def predict(self, X):
ret = LinearModel.predict(self, X)
return self._sigmoid(ret)
test_dataset = TensorDataset(test_input_0, test_input_1, test_length_0,
test_length_1, test_y)
train_dataloader = DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1)
test_dataloader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=1)
# Prepare model and optimizier
# model
if embedding_type != 'bert':
use_embedding = torch.FloatTensor(use_embedding)
model = LinearModel(len(rel2id), embedding_type, use_embedding,
freeze_embedding).to(device)
else:
try:
config = AutoConfig.from_pretrained(embedding)
bert_model = AutoModel.from_pretrained(embedding,
config=config).to(device)
except BaseException:
bert_model = torch.load(os.path.join(embedding,
'pytorch_model.bin')).to(device)
model = LinearModel(len(rel2id), embedding_type, bert_model,
freeze_embedding).to(device)
# optimizier
if embedding_type != 'bert':
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
if embedding_type == "bert":
def test_dims_input(self):
"""Check if error is raised when initializing the class with wrong type"""
with self.assertRaises(TypeError):
model = LinearModel(312.34)
def test_params_length(self):
"""Check if length of params attribute equals to dims vector"""
obs_dim = random.randint(1,10)
model = LinearModel(obs_dim)
self.assertEqual(len(model.params), obs_dim)
def setUp(self):
self.optimizer = Adam(0.1)
self.model = LinearModel(self.optimizer)
def setUp(self):
self.optimizer = Adam(0.1)
self.model = LinearModel(self.optimizer)
def predict(self, X, results_file):
pred = LinearModel.predict(self, X)
fp = open(results_file, 'w')
for v in pred.flat:
print >> fp, v
fp.close()
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 setUp(self):
self.optimizer = MomentumSGD(0.1)
self.model = LinearModel(self.optimizer)
def test_without_bias_with_regularization(self):
torch.manual_seed(24637882)
dataset_size = 20000
test_dataset_size = 1000
data_columns = 1
random_columns = 15
competitors = 8
regularization_lambda = 0.05
dataset_generator = ArtificialDataset(
dataset_size,
competitors,
data_columns,
rand_eps=1e-3,
number_of_random_columns=random_columns,
bias=False)
loader_iterator = iter(DataLoader(dataset_generator))
linear_model = LinearModel(data_columns + random_columns,
1,
bias=False) # number of columns to score
optimizer = torch.optim.Adam(params=linear_model.parameters())
loss = ExplodedLogitLoss(loss_type='bce')
for step in range(dataset_size):
data, order = next(loader_iterator)
optimizer.zero_grad()
score = linear_model(data).squeeze(-1)
loss_value = loss(score, order)
l1_loss_value = 0
for param in linear_model.parameters():
l1_loss_value += torch.sum(torch.abs(param))
loss_value += regularization_lambda * l1_loss_value
loss_value.backward()
optimizer.step()
if step % 1000 == 0:
print("Loss value: {0}".format(loss_value.item()))
with torch.no_grad():
for _ in range(test_dataset_size):
data, expected_order = next(loader_iterator)
score = linear_model(data).squeeze(-1)
actual_order = get_sort_order(score)
self.assertTrue(
torch.equal(actual_order, expected_order),
"Order not equal:\n{0}\n{1}".format(
actual_order, expected_order))
print("\n\nLinear transformation weights matrix\n--------------------")
print(linear_model.linear.weight)
print("\n\nInverted original coefficients\n--------------------")
print(dataset_generator.coeffs[0])
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()
assert args.load_weights is not None, "Use --load_weights"
self.state_fields = args.state_fields
self.state_size = len(self.state_fields)
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size, self.action_size)
self.model.load(args.load_weights)
self.episode = 0
self.onRestart()
self.show_sensors = args.show_sensors
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 drive(self, msg):
# parse incoming message
self.state.setFromMsg(msg)
# show sensors
if self.show_sensors:
self.stats.update(self.state)
state = np.array(sum(self.state.sensors.itervalues(), []), dtype=np.float)
state = state[self.state_fields]
#state = self.state.getTrack()
#state = [self.state.getAngle(), self.state.getSpeedX(), self.state.getTrackPos()]
steer, accel, brake = self.model.predict(state)
self.control.setSteer(steer)
self.control.setAccel(accel)
#self.control.setBrake(brake)
self.gear()
return self.control.toMsg()
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
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.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
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
def setUp(self):
self.optimizer = MomentumSGD(0.1)
self.model = LinearModel(self.optimizer)
def setUp(self):
self.optimizer = AdaDelta(eps=1e-5)
self.model = LinearModel(self.optimizer)
def setUp(self):
self.optimizer = RMSprop(0.1)
self.model = LinearModel(self.optimizer)
def test_gym():
env = gym.make('MountainCar-v0')
linear_func = LinearModel(feat_n, get_feature)
agent = QLearnAgent(act_n=3, linear_func=linear_func)
rs = gym_demo(env, agent, 500)
plt.plot(range(500), rs), plt.grid(), plt.show()
def setUp(self):
self.optimizer = AdaDelta(eps=1e-5)
self.model = LinearModel(self.optimizer)
"""use normal distribution generate x and error item"""
# data shape
input_num = 10000
# weight and bias
true_w = np.array([2, -3.4])
true_b = np.array([4.2])
# x / label / error
x = np.random.normal(loc=0, scale=1, size=(input_num, len(true_w)))
error = np.random.normal(loc=0, scale=0.01, size=input_num)
y = x @ true_w + true_b + error
"""draw a figure with the relationship between x and y by sample 1000 data"""
# set figure format
set_fig_display(axes_spines_state=[True, True, True, True])
# sample index
sample_index = np.random.choice(len(y), 1000)
draw_twin_fig(y[sample_index], x[sample_index, 0], x[sample_index, 1])
"""train model by mini-batch GD"""
params = {
"X": x,
"y": y,
"model": LinearModel(),
"epoch_num": 20,
"batch_size": 128,
}
model = train(**params)
print(f"w before update is {true_w}, w after update is {model.w}")
print(f"b before update is {true_b}, b after update is {model.b}")
def test_action_input(self):
"""Check if error is raised when length of params and obs are not the same"""
new_obs = [random.uniform(-1,1) for i in range(random.randint(5,10))]
model = LinearModel(self.regular_obs_dim)
with self.assertRaises(AssertionError):
model.action(new_obs)
from model_evaluation import r_squared
data = pd.read_csv("boston_house_price.txt", sep='|')
data = data[["LSTAT", "RM", "PTRATIO", "INDUS", "MEDV"]].values
data = (data - np.min(data)) / (np.max(data) - np.min(data))
N = data.shape[0]
RSQ = []
for step in range(1):
np.random.shuffle(data)
train = data[:int(N * 0.7), :]
test = data[int(N * 0.7):, :]
X_train = train[:, :-1]
Y_train = train[:, [-1]]
X_test = test[:, :-1]
Y_test = test[:, [-1]]
n_feat = X_train.shape[1]
model = LinearModel(n_feat)
model.training(X_train, Y_train, alpha=1.0, eps=0.001)
hatY_train = model.predict(X_train)
hatY_test = model.predict(X_test)
r1 = r_squared(Y_train, hatY_train)
r2 = r_squared(Y_test, hatY_test)
print(r1, r2)
sys.stdout.flush()
class Inference3d():
""" 3D Inference Class
Predict 3D pose from 2d pose
"""
def __init__(self, model_dir, params):
# self.init_model_params(params)
print('Initializing 3d pose model')
self.init_model_3d(params)
print('Finish initialization')
self.use_root = params['use_root']
model_file = os.path.join(model_dir, params['model_3d'])
mean_std_file = os.path.join(model_dir, params['mean_std_3d'])
print('Loading 3d pose model')
self.load_model_3d(load=model_file)
print('Finish loading 3d pose model')
self.load_mean_std(file=mean_std_file)
self.SH_TO_GT_PERM = np.array([6,2,1,0,3,4,5,7,8,9,13,14,15,12,11,10])
self.root2d_init = None
def init_model_3d(self, params):
# device_cout = {"GPU": 1}
# with tf.Session(config=tf.ConfigProto(
# device_count=device_count,
# allow_soft_placement=True )) as sess:
self.sess = tf.Session()
summaries_dir = os.path.join( params['train_dir'], params['summaries_dir'] )
self.linearModel = LinearModel(params['linear_size'], params['num_layers'], params['residual'], params['batch_norm'], \
params['max_norm'], params['batch_size'], params['learning_rate'], summaries_dir, params['use_root'], dtype=tf.float32)
self.linearModel.train_writer.add_graph( self.sess.graph)
def load_model_3d(self, load):
self.linearModel.saver.restore(self.sess, load)
def load_mean_std(self, file):
"""
load mean and std data of human pose from h5 file
these data are from h3.6m dataset
"""
with h5py.File(file, 'r') as h5f:
self.mean_2d = h5f['mean_2d'][:]
self.std_2d = h5f['std_2d'][:]
self.mean_3d = h5f['mean_3d'][:]
self.std_3d = h5f['std_3d'][:]
def predict_3dpose(self, data_2d):
"""
predict 3d pose from 2d pose
"""
data, data_root = self.read_data_input(data_2d)
data = np.reshape(data, [1, -1])
data_root = np.reshape(data_root, [1, -1])
outdim = 17*3 if self.use_root else 16*3
dec_out = np.zeros((data.shape[0], outdim), dtype=np.float32)
_, _, pose3d = self.linearModel.step(self.sess, data, dec_out, 1.0, isTraining=False)
pose3d = self.unNormalizeData(pose3d, self.mean_3d, self.std_3d)
pose3d[:,3:] = pose3d[:,3:] + np.tile(pose3d[:,:3], [1, int(pose3d.shape[1]/3)-1])
return pose3d
def read_data_input(self, data_2d):
"""
load 2d input data from 2d-pose-predict demo,
"""
poses = data_2d[self.SH_TO_GT_PERM, :]
poses = np.reshape(poses,[-1])
if self.root2d_init is None:
self.root2d_init = np.copy(poses[:2])
data, data_root = self.postprocess_data(poses, dim=2)
data = self.normalize_data( data, self.mean_2d, self.std_2d)
return data, data_root
def normalize_data(self, data, mu, stddev):
"""
Normalizes a dictionary of poses
Args
data: dictionary where values are
mu: np vector with the mean of the data
stddev: np vector with the standard deviation of the data
Returns
data_out: dictionary with same keys as data, but values have been normalized
"""
data_out = np.divide( (data - mu), stddev )
if self.use_root:
return data_out
else:
return data_out[2:]
def unNormalizeData(self, normalized_data, data_mean, data_std):
"""
Un-normalizes a matrix whose mean has been substracted and that has been divided by
standard deviation. Some dimensions might also be missing
Args
normalized_data: nxd matrix to unnormalize
data_mean: np vector with the mean of the data
data_std: np vector with the standard deviation of the data
Returns
orig_data: the input normalized_data, but unnormalized
"""
T, D = normalized_data.shape
if not self.use_root:
pad = np.zeros((T,3), dtype=np.float32)
normalized_data = np.hstack((pad,normalized_data))
D += 3
# Multiply times stdev and add the mean
stdMat = data_std.reshape((1, D))
stdMat = np.repeat(stdMat, T, axis=0)
meanMat = data_mean.reshape((1, D))
meanMat = np.repeat(meanMat, T, axis=0)
orig_data = np.multiply(normalized_data, stdMat) + meanMat
return orig_data
def postprocess_data( self, poses, dim ):
"""
Center 3d points around root
Args
poses: dictionary with 3d data
Returns
poses_set: dictionary with 3d data centred around root (center hip) joint
root_positions: dictionary with the original 3d position of each pose
"""
root_positions = {}
# for k in poses_set.keys():
# Keep track of the global position
root_positions = copy.deepcopy(poses[:dim])
# Remove the root from the 3d position
poses = poses - np.tile( poses[:dim], [poses.shape[0]/dim] )
poses[:dim] = root_positions - self.root2d_init
poses_set = poses
return poses_set, root_positions
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
