def get_parameters_from_cache(self, t: int, start: int = 0, n_best_parameters: int = 1): loss = self._Loss(self, t, start=start) optimizer = Optimizer(self.dimensions, cache_path=self.cache_path, **self._optimizer_kwargs) cached_result = optimizer.load_cached_result(loss) if n_best_parameters == 1: return get_optimal_parameters(cached_result) return get_n_best_parameters(n_best_parameters, cached_result)
def __init__(self): super(Beamline, self).__init__() self.voltages = Voltages() self.manager = mp.Manager() self.current = mp.Value('d', 0.0) self.current_std = mp.Value('d', 0.0) self.stamp = mp.Value('d', 0.0) self.readback = self.manager.dict() self.setpoints = self.manager.dict() for i in range(10): name = 'Control_{}'.format(str(i)) self.voltages[name] = Voltage(name=name) self.readback[name] = 0 self.setpoints[name] = 0 self.last = 0 self.max = 0 self.optimalTime = time.time() self.optimalSettings = self.voltages.setpoints self.continueScanning = False self.data = pd.DataFrame() self.optimizer = Optimizer(self) self.makeControlProcess() th.Timer(0, self.update).start() self.stop = False
def __init__(self, models, prediction_horizon, history_length, subsampling_rate, initial_controls, number_of_controls, number_of_variables): self.models = models self.prediction_horizon = prediction_horizon self.history_length = history_length self.initial_controls = initial_controls self.interpolated_controls = self.initial_controls self.initial_optimization_values = np.tile(self.initial_controls, prediction_horizon) self.subsampling_rate = subsampling_rate self.number_of_controls = number_of_controls self.number_of_variables = number_of_variables self.interpolated_tick = 0 self.optimizer = Optimizer() self.predictions = list() prediction.initialize_models()
class Control: def __init__(self, models, prediction_horizon, history_length, subsampling_rate, initial_controls, number_of_controls, number_of_variables): self.models = models self.prediction_horizon = prediction_horizon self.history_length = history_length self.initial_controls = initial_controls self.interpolated_controls = self.initial_controls self.initial_optimization_values = np.tile(self.initial_controls, prediction_horizon) self.subsampling_rate = subsampling_rate self.number_of_controls = number_of_controls self.number_of_variables = number_of_variables self.interpolated_tick = 0 self.optimizer = Optimizer() self.predictions = list() prediction.initialize_models() def get_next_actuators(self, full_track_history, current_tick): print(current_tick) if current_tick < self.subsampling_rate: current_actuators = self.initial_controls elif current_tick > 0 and current_tick % self.subsampling_rate == 0: self.interpolated_tick = current_tick % self.subsampling_rate history_array = prediction.prepare_tick_history( full_track_history.get_history(self.history_length, self.subsampling_rate)) predictions, optimized_actuators = self.optimizer.run_optimizer( self.models, history_array, self.prediction_horizon, self.initial_optimization_values, self.history_length, current_tick, self.subsampling_rate, self.number_of_controls, self.number_of_variables) self.predictions.append(predictions) current_actuators = optimized_actuators[:self.number_of_controls - 1] self.interpolated_controls = np.transpose( np.array([ np.linspace(i, j, self.subsampling_rate + 1) for i, j in zip( optimized_actuators[:self.number_of_controls - 1], optimized_actuators[(self.number_of_controls - 1):( 2 * (self.number_of_controls - 1))]) ])) self.initial_optimization_values = np.concatenate( [optimized_actuators[3:], self.initial_controls]) else: current_actuators = self.interpolated_controls[ self.interpolated_tick] return current_actuators def write_prediction(self, index): matrix = self.predictions[0][0][index] for optimization_run in self.predictions: for prediction_run in optimization_run: matrix = np.vstack((matrix, prediction_run[index])) np.savetxt('prediction_' + str(index) + '.txt', matrix, delimiter=',')
def fit(self, t: int, start: int = 0, n_best_parameters=1, **kwargs) -> Union[List[float], List[Tuple[float, List[float]]]]: loss = self._Loss(self, t, start=start) optimizer = Optimizer(self.dimensions, cache_path=self.cache_path, **self._optimizer_kwargs) previous_parameters = self.get_previous_parameters(t, start=t) optimization_result = optimizer.optimize( loss, initial_parameter_points=previous_parameters, **kwargs) self.results[(t, start)] = optimization_result self.parameters = get_optimal_parameters(optimization_result) if n_best_parameters == 1: return get_optimal_parameters(optimization_result) return get_n_best_parameters(n_best_parameters, optimization_result)
def __init__(self, T=None, n=None, pi="uniform", massmatrix=None, eigensolver=ScipySchur(), optimizer=Optimizer()): self.T = T self.n = n self.pi = get_pi(T, pi) self.massmatrix = massmatrix self.eigensolver = eigensolver self.optimizer = optimizer if T is not None: self.solve()
def train(args): bert_config = BertConfig(args.bert_config_path) bert_config.print_config() if not (args.do_train or args.do_test): raise ValueError("For args `do_train`, `do_test`, at " "least one of them must be True.") trainer_count = fluid.dygraph.parallel.Env().nranks task_name = args.task_name.lower() processors = { 'xnli': reader.XnliProcessor, 'cola': reader.ColaProcessor, 'mrpc': reader.MrpcProcessor, 'mnli': reader.MnliProcessor, } processor = processors[task_name](data_dir=args.data_dir, vocab_path=args.vocab_path, max_seq_len=args.max_seq_len, do_lower_case=args.do_lower_case, in_tokens=args.in_tokens, random_seed=args.random_seed) num_labels = len(processor.get_labels()) shuffle_seed = 1 if trainer_count > 1 else None train_data_generator = processor.data_generator( batch_size=args.batch_size, phase='train', epoch=args.epoch, dev_count=trainer_count, shuffle=args.shuffle, shuffle_seed=shuffle_seed) num_train_examples = processor.get_num_examples(phase='train') max_train_steps = args.epoch * num_train_examples // args.batch_size // trainer_count warmup_steps = int(max_train_steps * args.warmup_proportion) print("Device count: %d" % dev_count) print("Trainer count: %d" % trainer_count) print("Num train examples: %d" % num_train_examples) print("Max train steps: %d" % max_train_steps) print("Num warmup steps: %d" % warmup_steps) with fluid.dygraph.guard(place): if args.use_data_parallel: strategy = fluid.dygraph.parallel.prepare_context() cls_model = ClsModelLayer( args, bert_config, num_labels, is_training=True, return_pooled_out=True) optimizer = Optimizer( warmup_steps=warmup_steps, num_train_steps=max_train_steps, learning_rate=args.learning_rate, model_cls=cls_model, weight_decay=args.weight_decay, scheduler=args.lr_scheduler, loss_scaling=args.loss_scaling, parameter_list=cls_model.parameters()) if args.init_pretraining_params: print("Load pre-trained model from %s" % args.init_pretraining_params) init_from_static_model(args.init_pretraining_params, cls_model, bert_config) if args.use_data_parallel: cls_model = fluid.dygraph.parallel.DataParallel(cls_model, strategy) train_data_generator = fluid.contrib.reader.distributed_batch_reader(train_data_generator) steps = 0 time_begin = time.time() for batch in train_data_generator(): data_ids = create_data(batch) loss, accuracy, num_seqs = cls_model(data_ids) optimizer.optimization(loss, use_data_parallel = args.use_data_parallel, model = cls_model) cls_model.clear_gradients() if steps != 0 and steps % args.skip_steps == 0: time_end = time.time() used_time = time_end - time_begin current_example, current_epoch = processor.get_train_progress() localtime = time.asctime(time.localtime(time.time())) print("%s, epoch: %s, steps: %s, dy_graph loss: %f, acc: %f, speed: %f steps/s" % (localtime, current_epoch, steps, loss.numpy(), accuracy.numpy(), args.skip_steps / used_time)) time_begin = time.time() if steps != 0 and steps % args.save_steps == 0 and fluid.dygraph.parallel.Env().local_rank == 0: save_path = os.path.join(args.checkpoints, "steps" + "_" + str(steps)) fluid.save_dygraph( cls_model.state_dict(), save_path) fluid.save_dygraph( optimizer.optimizer.state_dict(), save_path) print("Save model parameters and optimizer status at %s" % save_path) steps += 1 if fluid.dygraph.parallel.Env().local_rank == 0: save_path = os.path.join(args.checkpoints, "final") fluid.save_dygraph( cls_model.state_dict(), save_path) fluid.save_dygraph( optimizer.optimizer.state_dict(), save_path) print("Save model parameters and optimizer status at %s" % save_path) return cls_model
# -*- coding: utf-8 -*- """ Created on Sun Sep 29 21:37:49 2019 @author: jezequel """ from objects import Accessory, Gear, Drive, Reductor, ShaftAssembly, Shaft, Generator from optimization import Optimizer import matplotlib.pyplot as plt from matplotlib import patches engine = Accessory(diameter=0.30, length=0.050, speed=4000, name='Engine') accessories = [Accessory(diameter=0.15, length=0.050, speed=2000, name='Fuel Pump'), Accessory(diameter=0.12, length=0.050, speed=3500, name='Starter'), Accessory(diameter=0.18, length=0.050, speed=750, name='Oil Pump')] generator = Generator(engine, accessories) limits = {'minimum' : {'x' : 0.2, 'y' : 0.05}, 'maximum' : {'x' : 0.7, 'y' : 0.3}} results = [] for reductor in generator.reductors: optimizer = Optimizer(reductor=reductor, limits=limits) res = optimizer.minimize(1000) print(res.success) print([gear.diameter for sa in optimizer.reductor.shaft_assemblies for gear in sa.gears]) print(optimizer.reductor.speeds()) results.append(optimizer.reductor)
answer = yesno_input( "Do you want to be able to thrash the data every region that is scanned? (y/n) " ) thrash_data = (answer == "y") optimizationScheme = input( "What version of the optimization routine do you want? Normal (0), Automatic quality rating (1), Fully automated (2) " ) while optimizationScheme not in ["0", "1", "2"]: print("Sorry, what did you say? ") optimizationScheme = input( "What version of the optimization routine do you want? Normal (0), Automatic quality rating (1), Fully automated (2) " ) if optimizationScheme == "0": OPT = Optimizer(config, config_conf, config_sted, thrash_data=thrash_data) elif optimizationScheme == "1": autoquality = yesno_input( "Do you want to change the parameters of the QualityNet? (y/n) ") if autoquality == "y": for key in config["autoquality"]: val = input("What should be the {}? ".format(key)) if key == "IP": config["autoquality"][key] = val else: config["autoquality"][key] = int(val) OPT = Optimizer(config, config_conf, config_sted, autoquality=True,