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 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 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")
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 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 = AdaDelta(eps=1e-5) 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()
"""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