def run(acc_operation): est = Estimator() a.write(b'\x01') lastTp = time.time() while True: data = a.read(14) raw_acc = read_data(data, 0) raw_gyr = read_data(data, 8) # print(data) tp = time.time() dt = tp - lastTp lastTp = tp # attitude estimation vp = est.feed_data(dt, raw_gyr, raw_acc) # print(vp, end="\r") for i in range(3): vp[i] = vp[i] * TIMES # print(vp) ret, logits = acc_operation.feed_data(vp) operation(ret, logits)
def run(model_dir): acce_operation = Acce_operation(model_dir) est = Estimator() a.write(b'\x01') window_data = np.array([[0 for i in range(TOTAL_WINDOW_SIZE)], [0 for i in range(TOTAL_WINDOW_SIZE)], [0 for i in range(TOTAL_WINDOW_SIZE)]], dtype=np.float32) index = 0 sample_num = 0 lastTp = time.time() while True: data = a.read(14) raw_acc = read_data(data, 0) raw_gyr = read_data(data, 8) tp = time.time() dt = tp - lastTp lastTp = tp # attitude estimation vp = est.feed_data(dt, raw_gyr, raw_acc) # print(vp, end="\r") for i in range(3): window_data[i][index] = vp[i] index += 1 sample_num += 1 if index == TOTAL_WINDOW_SIZE: index = 0 if sample_num == SAMPLE_SIZE: sample_num = 0 operate(acce_operation, window_data, index)
def __init__(self, fb, fs, pairs=None): Estimator.__init__(self, fs, pairs) self.csd_nfft = 256 self.csd_noverlap = self.csd_nfft / 2.0 self.fb = fb self.fs = fs
def find(self): estimator = Estimator() frame = self.video.get_next_frame() while frame is not None: start = time.time() # processing goes here predictions = self.get_predictions(frame) if not self.is_nsfw(predictions) and not self.maybe_nsfw( predictions): self.push_to_summary(self.current_frame_category, self.video.current_seconds) self.video_writer.write(frame) else: self.push_to_summary(self.current_frame_category, self.video.current_seconds) opt_blur = self.options["blur"] if opt_blur is not None: x, y = opt_blur.split(",") self.video_writer.write(blur(frame, (int(x), int(y)))) end = time.time() estimator.log_progress(start, end, self.video.current_frame_num, self.video.frames_count) frame = self.video.get_next_frame()
def __init__(self, name, logger, scheduler_queue, hub_queue, timer): self.name = name # e.g., 'UTIL' self.logger = logger self.scheduler_queue = scheduler_queue self.hub_queue = hub_queue self.timer = timer self.estimator = Estimator("estimator", self.logger) self.cluster_num_cpu = None self.cluster_num_mem = None self.cluster_num_bw = None self.cluster_num_gpu = None self.cluster_used_cpu = 0 self.cluster_used_mem = 0 self.cluster_used_gpu = 0 self.cluster_used_bw = 0 self._set_cluster_config() self.queueing_jobs = Queue.PriorityQueue() self.uncompleted_jobs = [] self.completed_jobs = [] self.cur_ts_completed_jobs = [] self.not_ready_jobs = set() self.exit_flag = False self.msg_handler = threading.Thread(target=self._msg_handle, args=()) self.msg_handler.start() self.scaling_overhead = 0 self.testing_overhead = 0
def __init__(self, fname=None): # Default values, see explanations below: taskDic = { 'taskName': 'total energy', 'tolerance': '1', 'nMaxSteps': '10' } Estimator.__init__(self,fname) Launcher.__init__(self,fname) # value to converge with respect to k-points or energy cutoffs # currently can be 'total energy', 'single phonon', or 'geometry': self.taskName = self.config.get('Task', 'taskName') # convergence criteria in percents: self.tolerance = self.config.getfloat('Task','tolerance') # maximum number of optimization steps: self.nMaxSteps = self.config.getint('Task','nMaxSteps') self.lookupTable = { 'total energy' : (self.pwscfLauncher, self.getTotalEnergy), 'single phonon': (self.singlePhononLauncher, self.getSinglePhonon), 'geometry' : (self.pwscfLauncher, self.getLatticeParameters), 'multiple phonon': (self.multiPhononLauncher, self.getMultiPhonon) } assert self.lookupTable.has_key(self.taskName), "Convergence \
def estimate_mu(verbose=True): sections_docs_training = read_training_docs() estimator = Estimator(**sections_docs_training) report = '\nEstimated mu: {}\n\n'.format(estimator.calculate_mu()) file = codecs.open('report.txt', 'w', encoding='utf-8') file.write(report) file.close() print(report)
def experiment(): args = parse_args() train_data = VIDataset(config.root_dir, is_train=True) eval_data = VIDataset(config.root_dir, is_train=False) estimator = Estimator(train_data, eval_data) estimator.train_roam(args)
def exp(args): estimator = Estimator(emb_dim=args.emb_dim, n_hidden=args.n_hidden, bidirectional=args.bi, n_layer=args.n_layer, dropout=args.dropout, lr=args.lr, decay=args.decay, lr_p=args.lr_p, clip=args.clip, batch_size=args.batch, epoch_num=args.epoch_num, cuda=args.cuda, path=args.path) vocab_size = estimator.vocab_size (train_batches, test_batches), id2rule, productions = estimator.dataset.parse( grammar_dict, root_rule) nonterminal2id, id2nonterminal = estimator.build_decode_dict(productions) model = Seq2seqModel(vocab_size=vocab_size, emb_dim=args.emb_dim, n_hidden=args.n_hidden, output_size=estimator.dataset.grammar.num_rules + 1, bidirectional=args.bi, n_layer=args.n_layer, dropout=args.dropout) m = torch.load('dirty/model') model.load_state_dict(m['net']) model.cuda() model.eval() total = 0 true_example = 0 for batch in test_batches: batch_actions = model.batch_decode(batch.questions, batch.src_lens, PAD, 200, nonterminal2id, id2nonterminal)[0] #id2rule也许可以被production替代 batch_actions = torch.stack(batch_actions).transpose(0, 1) total += len(batch_actions) for actions, logical_form in zip(batch_actions, batch.logical_forms): for i in range(len(actions)): if int(actions[i]) == 0: actions = actions[:i] break rule_str = [id2rule[int(act)] for act in actions] rule = normalize_prolog_variable_names( action_sequence_to_logical_form(rule_str)) if rule == logical_form: true_example += 1 else: print(rule) print(logical_form) print(rule_str) print('*' * 80)
def __run(params, single_run, fixed_votes, token): print(f"Running {token}") start_time = time.time() estimator = Estimator(params) output = estimator.run(single_run, fixed_votes) r.set(token, output.to_json(orient='records')) r.set(f"{token}_status", 'DONE') total_time = time.time() - start_time print(f"{token} DONE. Time: {total_time} seconds")
def __init__(self, node_list, gpu_per_node, job_executor): self.job_queue = [] self.init_job_queue = queue.Queue() self.cluster_resource = self.cluster_init(node_list, gpu_per_node) self.gpu_per_node = gpu_per_node self.current_wait_job = None self.job_executor = job_executor self.unpredicted_job = queue.Queue() self.estimator = Estimator() self.msg_handler = threading.Thread(target=self._msg_handle, args=()) self.msg_handler.start()
class PlantLogic: def __init__(self): self.data_access = DataAccess() self.estimator = Estimator() def commit_measurement( self, plant_id: int, water: int, temperature: float, humidity: int, light: int, moisture: int)\ -> Tuple[bool, int]: light_mmol = int(round(light / 54 * 3600 / 1000)) self.data_access.save_measurement(plant_id, water, temperature, humidity, light_mmol, moisture) plant_data = self.data_access.get_plant_data(plant_id) collected_light = self.data_access.get_todays_light_exposure(plant_id) light_on = False water_time = 0 if plant_data.dark_hours_start > time() > plant_data.dark_hours_end: estimated_total_light = self.estimator.estimate_total_light( collected_light, plant_data.dark_hours_start) if estimated_total_light < plant_data.light_low: light_on = True if plant_data.silent_hours_start > time( ) > plant_data.silent_hours_end: if moisture < plant_data.moisture_low + 10: water_time = (( (plant_data.pot_size / 2)**2 * np.pi * 0.04) / 280) * 3600 return light_on, water_time def configure(self, mac_address: str) -> int: return self.data_access.configure(mac_address)
def __init__(self, step_size=0.1, epsilon=0.1, symbol=0): self.step_size = step_size self.epsilon = epsilon self.previous_state = State() self.state = None self.symbol = symbol self.td_errors = [] self.estimator = Estimator() self.policy = make_epsilon_greedy_policy(self.estimator) self.action = (0, 0) self.actions = [] for i in range(BOARD_ROWS): for j in range(BOARD_COLS): self.actions.append((i, j))
def __init__( self, model, space, max_evals=200, random_seed=100, is_maximize=True, warm_start=False, trials_file_path=None, num_repeats=1, log_file_path=None, params_mapping={ 'n_estimators': int, 'num_leaves': int, 'max_depth': int, 'min_samples_leaf': int }, ): self.model_estimator = Estimator( model) if not model.__class__.__name__ == "Estimator" else model ''' model: model for which the hyperparamter tuning is to be done space: space for the model max_evals: number of rounds to run (put max_evals as 1 if you're passing catb_default_space for hyperparameter tuning) trials_file_path: file to dump trails of the experiment, also loads if present to continue from where it left log_file_path: file path for dumping logs params_mapping: dict of params_key and a callable function which to map the value of the key ''' if isinstance(space, dict): self.space = space elif isinstance(space, str): self.space = eval(space) else: raise ValueError("space not defined!") self.max_evals = max_evals self.trials_file_path = trials_file_path self.trials = self.load_trails() self.log_file_path = log_file_path self.params_mapping = params_mapping self.random_seed = random_seed self.warm_start = warm_start self.num_repeats = num_repeats self.is_maximize = is_maximize self.columns = None setup_logging(log_file=log_file_path)
def experiment(): train_input_fn = generate_input_fn(is_train=True, tfrecords_path=config.tfrecords_path, batch_size=config.batch_size, time_step=config.time_step) eval_input_fn = generate_input_fn(is_train=False, tfrecords_path=config.tfrecords_path, batch_size=config.batch_size_eval, time_step=config.time_step_eval) estimator = Estimator(train_input_fn=train_input_fn, eval_input_fn=eval_input_fn, model_fn=model_fn) estimator.train()
def create_model(): tokenizer = Tokenizer() estimator= Estimator(tokenizer) trainer = Trainer(tokenizer) estimator.load_name_cond_probs("data/probabilities/tokenized_authors_prob.txt") estimator.load_word_cond_probs("data/probabilities/conditional_not_a_name_prob.txt") # estimator.load_conditional_probabilities("data/probabilities/conditional_probs_4.txt") estimator.load_conditional_probabilities("data/probabilities/fold_" + str(fold) + ".txt") model = Model(tokenizer, estimator) return model
def main(): rospy.init_node("gpss_mower_controller") # Read and set parameters. robot_id = rospy.get_param("~robot_id") sampling_period = 1.0 / rospy.get_param("~sampling_frequency") horizon = rospy.get_param("~horizon") desire_speed = rospy.get_param("~desire_speed") deceleration_distance = rospy.get_param("~deceleration_distance") photo_activated = rospy.get_param("~photo_activated") print_status = rospy.get_param("~print_status") log_to_file = rospy.get_param("~log_to_file") max_speed = rospy.get_param("~max_forward_velocity") max_ang_speed = rospy.get_param("~max_angular_velocity") max_acc = rospy.get_param("~max_tan_acceleration") weight_x = rospy.get_param("~weight_x") weight_y = rospy.get_param("~weight_y") weight_theta = rospy.get_param("~weight_theta") weight_v = rospy.get_param("~weight_v") weight_w = rospy.get_param("~weight_w") min_speed = -max_speed min_ang_speed = -max_ang_speed min_acc = -max_acc mpc_weights = [weight_x, weight_y, weight_theta, weight_v, weight_w] constraints = [ max_speed, min_speed, max_ang_speed, min_ang_speed, max_acc, min_acc ] # Run the controller regulator = ltv_mpc.Regulator(robot_id, sampling_period, horizon, mpc_weights, constraints) TaskReceptor(robot_id, regulator, desire_speed, deceleration_distance) tf_manager = TfMng(robot_id, photo_activated) if photo_activated: Estimator(robot_id, regulator, tf_manager, Estimator.EKF_PHOTO_ODOM, print_status, log_to_file) else: Estimator(robot_id, regulator, tf_manager, Estimator.EKF_ODOM, print_status, log_to_file) # Blocks until ROS node is shutdown. rospy.spin()
def fit(self, X_train, y_train): config = self.config.copy() self.fitted_objects = {} for model in config["Pipelines"]["Model Layer"]: name = model['name'] if model["source"] == "Estimator": # creating estimator instance est = Estimator(model["model"], **model["params"], validation_scheme=self.validation_scheme, n_splits=self.n_splits) # performing Hyperparameter tuning if present if model.get('hpt'): hpt = HyperOptModelSelection(model=est, **model['hpt']['params']) hpt.fit(X_train, y_train) est = hpt.best_estimator # fitting estimator est.fit_transform(X_train, y_train) # saving serialized fitted model self.fitted_objects[name] = est.to_serialized_object() if model.get("pickle_path"): # saving model pickle, used for infrencing est.save_model(model.get("pickle_path"))
def fit(self, **kwds): """generate a learned model, trained on the given data Input: data: a mystic legacydata.dataset (or callable model, y = model(x)) rnd: bool, if False, treat the model as deterministic [default: True] cached: bool, if True, use a mystic.cache [default: False] NOTE: any additional keyword arguments will be passed to the estimator NOTE: if data is a model, estimator will use model's cached archive """ self.__kwds__.update(kwds) self.__kwds__.update(kwds) cached = self.__kwds__.pop('cached', False) archive = data = self.__kwds__.pop('data', None) self.rnd = self.__kwds__.pop('rnd', self.rnd) and (bool( self.__kwds__.get('noise', False))) if callable(data): #XXX: is a model, allow this? data = sample(data, bounds=None, pts=0) #XXX: axis? multivalue? elif isinstance(data, type('')): #XXX: is a name, allow this? import mystic.cache as mc import dataset as ds data = ds.from_archive(mc.archive.read(data)) x = getattr(data, 'coords', getattr(data, 'x', None)) z = getattr(data, 'values', getattr(data, 'y', None)) from estimator import Estimator estm = Estimator(x, z, **self.__kwds__) self.__func__ = estm.Train() #XXX: Error for zero-size? self.__model__ = _init_axis(estm.model) self.__model__.__name__ = self.__name__ self.__kwds__['data'] = archive if cached: #FIXME: clear the archive??? generate new uid name? self.__kwds__['cached'] = True self._OUQModel__init_cache() if hasattr(self.__model__, '__cache__'): c = self.__model__.__cache__() c.clear() else: self.__kwds__['cached'] = False return
def cmd_mode(): parser = argparse.ArgumentParser() parser.add_argument('--image', type=str, required=True, help='input image') parser.add_argument('--output', type=str, default='result.png', help='output image') parser.add_argument('--model', type=str, default='model.h5', help='path to the weights file') args = parser.parse_args() output = args.output keras_weights_file = args.model estimator = Estimator(keras_weights_file) # generate image with body parts if os.path.isdir(args.image): for file in os.listdir(args.image): fullpath = os.path.join(os.path.abspath(args.image),file) fpath,fname = os.path.split(fullpath) name,ext = os.path.splitext(fname) print(fullpath) if not os.path.isfile(fullpath) or ext not in image_exts: continue tic = time.time() frame = cv2.imread(fullpath) canvas = estimator.process_all(frame) toc = time.time() print ('processing time is %.5fs' % (toc - tic)) # saving output = os.path.join(fpath,'%s_processed%s'%(name,ext)) cv2.imwrite(output, canvas) else: fullpath = os.path.abspath(args.image) fpath,fname = os.path.split(fullpath) name,ext = os.path.splitext(fname) if not os.path.isfile(fullpath) or ext not in image_exts: return tic = time.time() frame = cv2.imread(fullpath) canvas = estimator.process_all(frame) toc = time.time() print ('processing time is %.5fs' % (toc - tic)) # saving output = os.path.join(fpath,'%s_processed%s'%(name,ext)) cv2.imwrite(output, canvas)
def __init__(self): self.on = True self.motor_on = False self.save_on = False self.mode = 0 self.t0 = datetime.datetime.now() self.t = 0.0 self.t_pre = 0.0 self.freq_imu = 0.0 self.freq_gps = 0.0 self.freq_control = 0.0 self.freq_log = 0.0 self.x = np.zeros(3) self.v = np.zeros(3) self.a = np.zeros(3) self.R = np.identity(3) self.W = np.zeros(3) self.x_offset = np.zeros(3) self.yaw_offset = 0.0 self.g = 9.81 self.ge3 = np.array([0.0, 0.0, self.g]) # Gazebo uses ENU frame, but NED frame is used in FDCL. self.R_fg = np.array([[1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]]) self.V_R_imu = np.diag([0.01, 0.01, 0.01]) self.V_x_gps = np.diag([0.01, 0.01, 0.01]) self.V_v_gps = np.diag([0.01, 0.01, 0.01]) self.control = Control() self.control.use_integral = True # Enable integral control self.estimator = Estimator() self.trajectory = Trajectory() self.lock = threading.Lock()
def estimate_price(self, stock_name: str, year: str, month: str, day: str) -> float: """ Estimates price of the stock sent as parameter. Based on the date which is sent as parameter, it takes the month from the date and filters all the stock_name stocks which have a date in the specified month and does the average of the mid range price (average between high and low price) :param stock_name: stock name for which we try to predict :param year: :param month: :param day: :return: returns the prediction """ reader = Reader() self._dateset = reader.load_data("./dow_jones_index.csv") self._dateset = reader.clean_data(self._dateset) estimator = Estimator() estimator.fit(self._dateset) stock_prediction = estimator.predict(stock_name, year, month, day) return stock_prediction
def predict(self, X_test): config = self.config.copy() df = pd.DataFrame({"id": range(len(X_test))}) for model in config["Pipelines"]["Model Layer"]: name = model['name'] if model["source"] == "Estimator": # creating estimator instance if hasattr(self, 'fitted_objects'): # loading from serialized object in memory est = Estimator.from_serialized_object( self.fitted_objects[name]) elif model.get("pickle_path"): # loading model from saved pickle est = Estimator.load_model(model.get("pickle_path")) else: raise ValueError("Model not fitted/File Not found!") # generating predictions df[name] = est.transform(X_test) return df
def __init__(self, load=None, filepath='best_estimator.h5', num_episodes=400, eval_episodes=20, update_freq=80, mcts_iters=100, tau_cutoff=20): self.num_episodes = num_episodes self.eval_episodes = eval_episodes self.update_freq = update_freq self.mcts_iters = mcts_iters self.tau_cutoff = tau_cutoff self.filepath = filepath to_load = load or filepath if os.path.isfile(to_load): self.estimator = Estimator(State.raw_shape, len(State.domain), filepath=to_load) else: self.estimator = Estimator(State.raw_shape, len(State.domain))
def __init__(self, args): self.estimator = Estimator(emb_dim=args.emb_dim, n_hidden=args.n_hidden, bidirectional=args.bi, n_layer=args.n_layer, dropout=args.dropout, lr=args.lr, decay=args.decay, lr_p=args.lr_p, clip=args.clip, batch_size=args.batch, epoch_num=args.epoch_num, cuda=args.cuda, path=args.path) self.transformer = Transformer(prolog_grammar.GRAMMAR_DICTIONARY, prolog_grammar.ROOT_RULE) self.performances = [] self.actions = [] self.path = args.path
def run(): pl.ion() pl.show() est = Estimator() a.write(b'\x01') window_data = np.array([[0 for i in range(WINDOW_SIZE)], [0 for i in range(WINDOW_SIZE)], [0 for i in range(WINDOW_SIZE)]]) pl.show() index = 0 sample_num = 0 lastTp = time.time() for i in range(3): line, = ax.plot(window_data[i]) lines.append(line) while True: data = a.read(14) raw_acc = read_data(data, 0) raw_gyr = read_data(data, 8) tp = time.time() dt = tp - lastTp lastTp = tp # attitude estimation vp = est.feed_data(dt, raw_gyr, raw_acc) print(vp, end="\r") for i in range(3): window_data[i][index] = vp[i] * 512 index += 1 sample_num += 1 if index == WINDOW_SIZE: index = 0 if sample_num == SAMPLE_SIZE: sample_num = 0 ret_data = np.concatenate( [window_data[:, index:], window_data[:, :index]], axis=1) plot(ret_data)
def __init__(self, cfg): """ All factors are loaded from configuration. """ self.cfg = cfg self.voc = Vocabulary() self.unigram = Vocabulary() self.tags = list() self.meta_info = dict() self.sentences = list() file_name = self.cfg.file_name('use_lemma', 'word_freq', 'k', 'len_threshold', 'no_delta_match', 'filter', 'preprocessed') file_name = self.cfg.cache('scenario', file_name) if os.path.exists(file_name): with open(file_name, 'rb') as fp: self.data = pickle.load(fp) self._init_executor() self._build_voc() else: measure('preprocessing') self.data = load_roto_wire() self._build_voc() self._convert_to_matrix() self._init_executor() self._pre_calculate() with open(file_name, 'wb') as fp: pickle.dump(self.data, fp) self.special_tokens = self.voc[special_tokens] self.estimator = Estimator(self.sentences, self.meta_info, len(self.unigram), len(self.voc), self.special_tokens, self.cfg) self.tag_maps = simplify_tags(self.tags) measure('End-trainer-init')
class acc_module(threading.Thread): def __init__(self, feed_data_func): threading.Thread.__init__(self) self.feed_data = feed_data_func self.serial_port = serial.Serial('/dev/ttyACM0', 115200) self.est = Estimator() def run(self): lastTp = time.time() while True: data = self.serial_port.read(14) raw_acc = read_data(data, 0) raw_gyr = read_data(data, 8) tp = time.time() dt = tp - lastTp lastTp = tp # attitude estimation vp = self.est.feed_data(dt, raw_gyr, raw_acc) self.feed_data(vp)
def fit(self, X, y, columns=None): logger.info( "Starting HyperOpt {} Evals with Dataset of Shape ({},{})".format( self.max_evals, X.shape, y.shape)) self.x, self.y = copy.deepcopy(X), copy.deepcopy(y) self.columns = columns if not self.warm_start: self.trials = Trials() best = self() self.save_trails() self.best_score = self.get_best_result()['misc']['eval_score'] self.best_params = self.get_best_params() logger.info("Best Score- {}, Best Params- {}".format( self.best_score, self.best_params)) model_estimator_params = self.model_estimator.get_params() model_estimator_params['model']['params'].update(self.best_params) self.best_estimator = Estimator(**model_estimator_params) self.best_model = self.best_estimator.model del self.x, self.y return self
def objective(self, params): params = self._params_mapping(params) self.iteration += 1 logger.debug("\nIteration: {}, Training with params: {}".format( self.iteration, params)) model_estimator_params = self.model_estimator.get_params() # updating model params model_estimator_params['model']['params'].update(params) model_estimator = Estimator(**model_estimator_params) score = evaluate(self.x, self.y, model_estimator, num_repeats=self.num_repeats, fs_individual=self.columns) loss = -1 * score['eval_score'] if self.is_maximize else score[ 'eval_score'] logger.debug("Score - {}, Std - {}, Eval Score - {}".format( score["avg_cv_score"], np.std(score['cv_scores']), score["eval_score"])) logger.debug("Score across folds - {}.".format(score["cv_scores"])) return {'loss': loss, 'status': STATUS_OK, 'misc': score}
parser.add_argument('-d', '--debug', help="Verbose output needed", type=int, default=0) sysargs = parser.parse_args() # verbose printing for different debug levels def verbose_print(level, *args): if level <= int(sysargs.debug): for arg in args: print arg, else: pass e = Event() r_arrival = RandDist(*P[sysargs.arrival_process]) r_service = RandDist(5, triangular, {'b': 0.99}) e.add_event("arrival", r_arrival) e.add_event("serviced", r_service) est=Estimator(1.96, "95%") for i in range(sysargs.num_reps): q = do_rep(e) est.process_next_val(q) print P[sysargs.arrival_process] print "Point Estimate:", est.get_mean() print est.get_conf_interval() print est.get_rel_error()
def __init__(self,priors,data,model=None): self.data = data self.model = model Estimator.__init__(self,priors)