def InitializeSubProcesses(self): """Initialize subprocess modules based on config.yaml.""" if self.config.get('gps'): self.gps = gps_sensor.GPSProcess(self.config, self.point_queue) while self.point_queue.empty(): self.point = gps_pb2.Point().FromString(self.point_queue.get()) logging.log_every_n_seconds( logging.INFO, 'Waiting for GPS fix to determine track before starting other ' 'sensor subprocesses', 10) break self.ProcessSession() if self.config.get('accelerometer'): self.accel = accelerometer.AccelerometerProcess( self.config, self.point_queue) if self.config.get('gyroscope'): self.gyro = gyroscope.GyroscopeProcess(self.config, self.point_queue) if self.config.get('labjack'): self.labjack = labjack.Labjack(self.config, self.point_queue) if self.config.get('tire_temps'): self.tire_temps = tire_temperature.MultiTireInterface( self.config, self.point_queue) if self.config.get('wbo2'): self.wbo2 = wbo2.WBO2(self.config, self.point_queue) if self.config.get('timescale'): self.timescale = timescale.Timescale( timescale.CreateSession(self.session)) if self.config.get('rtmp_overlay'): self.rtmp_overlay = rtmp_overlay.RTMPOverlay(self.config)
def ReadValues(self): """Reads the labjack voltages.""" try: if self.config.get('labjack'): point = gps_pb2.Point() point.labjack_temp_f = ( self.u3.getTemperature() * 9.0/5.0 - 459.67) for input_name, proto_field in self.config['labjack'].items(): if input_name.startswith('ain') or input_name.startswith('fio'): channel = int(input_name[-1]) # Note getFeedback(u3.AIN(4)) is reading voltage from FIO4. # Physically AIN4 and FIO4 are identical. AIN is for analog input # and FIO is flexible input/output. feedback = self.u3.getFeedback(u3.AIN(channel))[0] is_low_voltage = channel not in self.HIGH_VOLTAGE_CHANNELS voltage = self.u3.binaryToCalibratedAnalogVoltage( feedback, isLowVoltage=is_low_voltage, channelNumber=channel) if input_name in self.config['labjack'].get('tick_divider_10'): voltage = voltage * 10 setattr(point, proto_field, voltage) self.AddPointToQueue(point) except u3.LabJackException: stack_trace = ''.join(traceback.format_exception(*sys.exc_info())) logging.log_every_n_seconds(logging.ERROR, 'Error reading labjack values\n%s', 10, stack_trace)
def afkmc2(data, k, m=20): """Implementation of Fast and Provably Good Seedings for k-Means https://las.inf.ethz.ch/files/bachem16fast.pdf """ n = data.shape[0] c1 = np.random.randint(data.shape[0]) c1_vec = np.expand_dims(data[c1], 0) q_nom = np.squeeze(euc_dist_batched(c1_vec, data)) q_denom = np.sum(q_nom) q = 0.5 * q_nom / q_denom + 1.0 / (2.0 * n) indices = np.arange(n) c_i_minus_1 = np.zeros((k, data.shape[1]), dtype=np.float32) c_i_minus_1[0, :] = c1_vec for i in range(1, k): logging.log_every_n_seconds(logging.INFO, 'afkmc2 processed %s of %s', 5, i, k) x_ind = np.random.choice(indices, p=q) x = np.expand_dims(data[x_ind], 0) d_x = np.min(np.squeeze(euc_dist_batched(x, c_i_minus_1[:i]))) for j in range(1, m): y_ind = np.random.choice(indices, p=q) y = np.expand_dims(data[y_ind], 0) d_y = np.min(np.squeeze(euc_dist_batched(y, c_i_minus_1[:i]))) if ((d_y * q[x_ind]) / (d_x * q[y_ind])) > np.random.rand(): x = y d_x = d_y c_i_minus_1[i] = x return c_i_minus_1
def WaitUntilModelLoaded(self, deadline: float, polling_interval_sec: int) -> None: """Wait until model is loaded and available. Args: deadline: A deadline time in UTC timestamp (in seconds). polling_interval_sec: GetServingStatus() polling interval. Raises: DeadlineExceeded: When deadline exceeded before model is ready. ValidationFailed: If validation failed explicitly. """ while time.time() < deadline: status = self._GetServingStatus() if status == types.ModelServingStatus.NOT_READY: logging.log_every_n_seconds( level=logging.INFO, n_seconds=10, msg='Waiting for model to be loaded...') time.sleep(polling_interval_sec) continue elif status == types.ModelServingStatus.UNAVAILABLE: raise error_types.ValidationFailed( 'Model server failed to load the model.') else: logging.info('Model is successfully loaded.') return raise error_types.DeadlineExceeded( 'Deadline exceeded while waiting the model to be loaded.')
def __init__(self, entity_info_file, name, get_field, norm=None): logging.info('building entity kb...') with open(entity_info_file, 'rb') as f: [self.entity_ids, self.entity_names] = pickle.load(f) self.emap = dict() self.missing_entities = ['army', 'navy'] if not os.path.exists(entity_info_file + '.cache.pkl'): for idx in range(len(self.entity_ids)): logging.log_first_n(logging.INFO, 'entity kb: %s -> %s', 10, self.entity_names[idx], idx) logging.log_every_n_seconds(logging.INFO, 'entity kb: %s of %s', 10, idx, len(self.entity_ids)) self.emap[self.entity_names[idx].lower()] = idx normalized = normalize_name(self.entity_names[idx]) splt = split(normalized) cleaned = clean(splt) nostop = remove_stopwords(cleaned) if normalized not in self.emap: self.emap[normalized] = idx if splt not in self.emap: self.emap[splt] = idx if cleaned not in self.emap: self.emap[cleaned] = idx if nostop not in self.emap: self.emap[nostop] = idx for me in self.missing_entities: self.emap[me] = len(self.emap) with open(entity_info_file + '.cache.pkl', 'wb') as fout: pickle.dump(self.emap, fout) else: with open(entity_info_file + '.cache.pkl', 'rb') as fin: self.emap = pickle.load(fin) self.name = name self.get_field = get_field logging.info('building entity kb...done')
def _rmat_to_euler_xyz(rmat): """Converts a 3x3 rotation matrix to XYZ euler angles.""" # | r00 r01 r02 | | cy*cz -cy*sz sy | # | r10 r11 r12 | = | cz*sx*sy+cx*sz cx*cz-sx*sy*sz -cy*sx | # | r20 r21 r22 | | -cx*cz*sy+sx*sz cz*sx+cx*sy*sz cx*cy | if rmat[0, 2] > _POLE_LIMIT: logging.log_every_n_seconds(logging.WARNING, 'Angle at North Pole', 60) z = np.arctan2(rmat[1, 0], rmat[1, 1]) y = np.pi / 2 x = 0.0 return np.array([x, y, z]) if rmat[0, 2] < -_POLE_LIMIT: logging.log_every_n_seconds(logging.WARNING, 'Angle at South Pole', 60) z = np.arctan2(rmat[1, 0], rmat[1, 1]) y = -np.pi / 2 x = 0.0 return np.array([x, y, z]) z = -np.arctan2(rmat[0, 1], rmat[0, 0]) y = np.arcsin(rmat[0, 2]) x = -np.arctan2(rmat[1, 2], rmat[2, 2]) # order of return is the order of input return np.array([x, y, z])
def Loop(self): with serial.Serial('/dev/ttyUSB0', 19200) as ser: for frame in ReadSerial(ser): logging.log_every_n_seconds(logging.DEBUG, 'WBO2 Frame: %s', 10, frame) for frame_key, point_value in self.config['wbo2'].items(): self.values[point_value].value = GetBytes(frame, frame_key)
def batch_find_neighbors(X, nn: NearestNeighbors, batch_size=1000): res = np.zeros((X.shape[0], nn.n_neighbors - 1), dtype=np.int32) for i in range(0, X.shape[0], batch_size): logging.log_every_n_seconds( logging.INFO, 'Computed %s of %s neighbors' % (i, X.shape[0]), 5) res[i:(i + batch_size)] = nn.kneighbors(X[i:(i + batch_size), :], return_distance=False)[:, 1:] logging.info('Finished batch_find_neighbors') return res
def test_sac_algorithm_discrete(self, use_parallel_network): num_env = 1 config = TrainerConfig( root_dir="dummy", unroll_length=1, mini_batch_length=2, mini_batch_size=64, initial_collect_steps=500, whole_replay_buffer_training=False, clear_replay_buffer=False, num_envs=num_env, ) env_class = PolicyUnittestEnv steps_per_episode = 13 env = env_class(num_env, steps_per_episode, action_type=ActionType.Discrete) eval_env = env_class(100, steps_per_episode, action_type=ActionType.Discrete) obs_spec = env._observation_spec action_spec = env._action_spec fc_layer_params = (10, 10) q_network = partial(QNetwork, fc_layer_params=fc_layer_params) alg2 = SacAlgorithm(observation_spec=obs_spec, action_spec=action_spec, q_network_cls=q_network, use_parallel_network=use_parallel_network, env=env, config=config, critic_optimizer=alf.optimizers.Adam(lr=1e-3), alpha_optimizer=alf.optimizers.Adam(lr=1e-2), debug_summaries=False, name="MySAC") eval_env.reset() for i in range(700): alg2.train_iter() if i < config.initial_collect_steps: continue eval_env.reset() eval_time_step = unroll(eval_env, alg2, steps_per_episode - 1) logging.log_every_n_seconds( logging.INFO, "%d reward=%f" % (i, float(eval_time_step.reward.mean())), n_seconds=1) self.assertAlmostEqual(1.0, float(eval_time_step.reward.mean()), delta=0.2)
def euc_dist_batched(x_i, nodes, batch_size=1000): """Batched cdist operation.""" dists = np.zeros((x_i.shape[0], nodes.shape[0]), np.float32) for i in range(0, x_i.shape[0], batch_size): logging.log_every_n_seconds(logging.INFO, 'euc_dist_batched processed %s of %s', 5, i, x_i.shape[0]) for j in range(0, nodes.shape[0], batch_size): logging.log_every_n_seconds(logging.INFO, 'euc_dist_batched processed %s of %s', 5, j, nodes.shape[0]) dists[i:(i + batch_size), j:(j + batch_size)] = squared_euclidean_cdist( x_i[i:(i + batch_size), :], nodes[j:(j + batch_size), :]).numpy() return dists
def p_par_to_batched_np(self, x_i, nodes, batch_size=1000): dists = np.zeros((x_i.shape[0], nodes.shape[0]), np.float32) for i in range(0, x_i.shape[0], batch_size): logging.log_every_n_seconds( logging.INFO, 'p_par_to_batched_np processed %s of %s', 5, i, x_i.shape[0]) for j in range(0, nodes.shape[0], batch_size): dists[i:(i + batch_size), j:(j + batch_size)] = self.p_par_to_broadcast( x_i[i:(i + batch_size), :], nodes[j:(j + batch_size), :]).numpy() return dists
def write_tsv(self, filename, leaves, pids=None, lbls=None, update_cache=True): logging.info('Writing tree tsv to %s' % filename) logging.info('num leaves %s' % leaves.shape[0]) logging.info('pids is None? %s' % (pids is None)) logging.info('lbls is None? %s' % (lbls is None)) internals = self.internals.numpy() leaf_to_par_assign = self.p_par_assign_to(leaves, internals) internal_to_par_assign = self.p_par_assign_to_internal( internals, internals, proj_child=False) self.cached_pairs = np.concatenate([ np.expand_dims(np.arange(internal_to_par_assign.shape[0]), 1), np.expand_dims(internal_to_par_assign, 1) ], axis=1) self.cached_pairs = self.cached_pairs[self.cached_pairs[:, 1] != -1] with open(filename + '.internals', 'w') as fouti: with open(filename + '.leaves', 'w') as foutl: with open(filename, 'w') as fout: i = -1 pid = 'int_%s' % i best_pid = 'best_int_%s' % i par_id = 'None' fout.write('%s\t%s\tNone\n' % (pid, par_id)) fout.write('%s\t%s\tNone\n' % (best_pid, pid)) fouti.write('%s\t%s\tNone\n' % (pid, par_id)) fouti.write('%s\t%s\tNone\n' % (best_pid, pid)) for i in range(leaf_to_par_assign.shape[0]): logging.log_every_n_seconds(logging.INFO, 'Wrote %s leaves' % i, 5) pid = 'pt_%s' % i if pids is None else pids[i] lbl = pid if lbls is None else lbls[i] par_id = 'best_int_%s' % leaf_to_par_assign[i] fout.write('%s\t%s\t%s\n' % (pid, par_id, lbl)) foutl.write('%s\t%s\t%s\n' % (pid, par_id, lbl)) for i in range(internal_to_par_assign.shape[0]): logging.log_every_n_seconds(logging.INFO, 'Wrote %s internals' % i, 5) pid = 'int_%s' % i par_id = 'int_%s' % internal_to_par_assign[i] best_pid = 'best_int_%s' % i fout.write('%s\t%s\tNone\n' % (pid, par_id)) fout.write('%s\t%s\tNone\n' % (best_pid, par_id)) fouti.write('%s\t%s\tNone\n' % (pid, par_id)) fouti.write('%s\t%s\tNone\n' % (best_pid, par_id))
def ReplayLog(filepath, include_sleep=False): """Replays data, extermely useful to LED testing. Args: filepath: A string of the path of lap data. include_sleep: If True replays adds sleeps to simulate how data was processed in real time. Returns: A exit_speed_main.ExitSpeed instance that has replayed the given data. """ logging.info('Replaying %s', filepath) logger = data_logger.Logger(filepath) points = list(logger.ReadProtos()) logging.info('Number of points %d', len(points)) if include_sleep: replay_start = time.time() time_shift = int(replay_start * 1e9 - points[0].time.ToNanoseconds()) session_start = None else: FLAGS.set_default('commit_cycle', 10000) es = exit_speed_main.ExitSpeed(live_data=not include_sleep) es.point = points[0] es.point_queue.put(points[0].SerializeToString()) es.config['car'] = os.path.split(os.path.dirname(filepath))[1] es.InitializeSubProcesses() es.AddNewLap() for point in points: if include_sleep: point.time.FromNanoseconds(point.time.ToNanoseconds() + time_shift) if not session_start: session_start = point.time.ToMilliseconds() / 1000 es.point = point es.ProcessLap() if include_sleep: run_delta = time.time() - replay_start point_delta = point.time.ToMilliseconds() / 1000 - session_start if run_delta < point_delta: time.sleep(point_delta - run_delta) if not include_sleep: time.sleep(1) qsize = len(es.timescale.point_queue) while qsize > 0: qsize = len(es.timescale.point_queue) logging.log_every_n_seconds(logging.INFO, 'Queue size %s', 2, qsize) es.timescale.stop_process_signal.value = True print(time.time()) es.timescale.process.join(10) print(time.time()) return es
def process_file(point2clusters, clusters, pkl_file): res = pickle.load(open(pkl_file, 'rb')) num_assign = 0 for c, res in res.items(): logging.log_first_n(logging.INFO, 'canopy %s', 5, c) for idx in range(len(res[0])): if res[1][idx] not in clusters: logging.log_every_n_seconds(logging.INFO, 'new cluster %s -> %s', 1, res[1][idx], len(clusters)) clusters[res[1][idx]] = len(clusters) point2clusters[res[0][idx]].append(clusters[res[1][idx]]) logging.log_every_n_seconds(logging.INFO, 'points %s -> %s', 1, res[0][idx], clusters[res[1][idx]]) num_assign += 1 return num_assign
def Run(self) -> None: """Runs exit speed in a loop.""" self.InitializeSubProcesses() self.AddNewLap() while True: self.point = gps_pb2.Point().FromString(self.point_queue.get()) self.ProcessLap() logging.log_every_n_seconds( logging.INFO, 'Main: Point queue size currently at %d.', 10, self.point_queue.qsize()) self.sdnotify.notify('STATUS=Last report time:%s' % self.point.time.ToJsonString()) self.sdnotify.notify('WATCHDOG=1')
def _train(self): for env in self._envs: env.reset() time_step = self._driver.get_initial_time_step() policy_state = self._driver.get_initial_policy_state() iter_num = 0 while True: t0 = time.time() with record_time("time/train_iter"): time_step, policy_state, train_steps = self._train_iter( iter_num=iter_num, policy_state=policy_state, time_step=time_step) t = time.time() - t0 logging.log_every_n_seconds(logging.INFO, '%s time=%.3f throughput=%0.2f' % (iter_num, t, int(train_steps) / t), n_seconds=1) if (iter_num + 1) % self._checkpoint_interval == 0: self._save_checkpoint() if self._evaluate and (iter_num + 1) % self._eval_interval == 0: self._eval() if iter_num == 0: # We need to wait for one iteration to get the operative args # Right just give a fixed gin file name to store operative args common.write_gin_configs(self._root_dir, "configured.gin") with tf.summary.record_if(True): def _markdownify(paragraph): return " ".join( (os.linesep + paragraph).splitlines(keepends=True)) common.summarize_gin_config() tf.summary.text('commandline', ' '.join(sys.argv)) tf.summary.text( 'optimizers', _markdownify(self._algorithm.get_optimizer_info())) tf.summary.text('revision', git_utils.get_revision()) tf.summary.text('diff', _markdownify(git_utils.get_diff())) tf.summary.text('seed', str(self._random_seed)) # check termination env_steps_metric = self._driver.get_step_metrics()[1] total_time_steps = env_steps_metric.result().numpy() iter_num += 1 if (self._num_iterations and iter_num >= self._num_iterations) \ or (self._num_env_steps and total_time_steps >= self._num_env_steps): break
def step(start, end): for i in range(start, end): token_indices_sequence = dataset.token_indices[dataset_type][i] feed_dict = { model.input_token_indices: token_indices_sequence, model.input_leading_spaces: dataset.leading_spaces[dataset_type][i], model.input_capitalization: model.InputCapitalization.create_columns(map(dataset.index_to_token.get, token_indices_sequence)), model.input_token_character_indices: dataset.character_indices_padded[dataset_type][i], model.input_token_lengths: dataset.token_lengths[dataset_type][i], model.input_label_indices_vector: dataset.label_vector_indices[dataset_type][i], model.dropout_keep_prob: 1., model.recall_inference_bias: parameters['recall_inference_bias'] if not parameters['train_model'] else 0.0, } res[i] = unary_scores, predictions = sess.run([model.unary_scores, model.predictions], feed_dict) logging.log_every_n_seconds(logging.INFO, 'Predict... run model [{dataset}] {percent}%'.format(dataset=dataset_type ,percent=round(100*i/len(dataset.token_indices[dataset_type]), ndigits=1)), n_seconds=10)
def __log_status(block): is_root = isinstance(block, RootBlock) shard = "R" if is_root else block.header.branch.get_shard_id() count = len(block.minor_block_header_list) if is_root else len( block.tx_list) elapsed = time.time() - block.header.create_time GLOG.log_every_n_seconds( GLOG.INFO, "[{}] {} [{}] ({:.2f}) {}".format( shard, block.header.height, count, elapsed, block.header.get_hash().hex(), ), 60, )
def process(self, element): """Transform text and labels to a machine learning ready form. Beam DoFn to generate a DataAndLabels of the features to be used in training. Yields key values tuples where the key is the label source. Args: element: Keyed APData Yields: key, value pair of the APData with the added features. """ (key, ap_data) = element # Get Features: token_features = generate_token_features(ap_data.tokens, self._vocab) # Get labels: labels = generate_model_labels(ap_data.labeled_char_spans, ap_data.tokens) # Filter whitespaces: token_mask = [t.token_text == " " for t in ap_data.tokens] tokens = self.filter_whitespaces(ap_data.tokens, token_mask) self.seq_length_dist.update(len(tokens)) if self._max_seq_length and len(tokens) > self._max_seq_length: self.over_max_seq_length.inc() logging.log_every_n_seconds(logging.INFO, "AP section too long: %d tokens", 3, len(tokens)) return token_features = self.filter_whitespaces_dict(token_features, token_mask) labels = self.filter_whitespaces_dict(labels, token_mask) # Pad. token_features = self.pad(token_features, value=0) labels = self.pad(labels, value=-1) ap_data.tokens = tokens ap_data.token_features = token_features ap_data.labels = labels yield (key, ap_data)
def ReadValues(self): """Reads the labjack voltages.""" try: results = self.u3.getFeedback(*self.commands) for command in self.commands: result = results[self.commands.index(command)] voltage = self.u3.binaryToCalibratedAnalogVoltage( result, isLowVoltage=False, channelNumber=command.positiveChannel) proto_field = self.command_proto_field[command] self.voltage_values[proto_field].value = voltage except u3.LabJackException: stack_trace = ''.join(traceback.format_exception(*sys.exc_info())) logging.log_every_n_seconds(logging.ERROR, 'Error reading labjack values\n%s', 10, stack_trace)
def test_sarsa(self, on_policy=False, sac=True, use_rnn=False, priority_replay=False): logging.info("sac=%d on_policy=%s use_rnn=%s" % (sac, on_policy, use_rnn)) env_class = PolicyUnittestEnv iterations = 500 num_env = 128 if on_policy: num_env = 128 steps_per_episode = 12 env = env_class(num_env, steps_per_episode, action_type=ActionType.Continuous) eval_env = env_class(100, steps_per_episode, action_type=ActionType.Continuous) algorithm = _create_algorithm(env, on_policy=on_policy, sac=sac, use_rnn=use_rnn, priority_replay=priority_replay) env.reset() eval_env.reset() for i in range(iterations): algorithm.train_iter() eval_env.reset() eval_time_step = unroll(eval_env, algorithm, steps_per_episode - 1) logging.log_every_n_seconds( logging.INFO, "%d reward=%f" % (i, float(eval_time_step.reward.mean())), n_seconds=1) self.assertAlmostEqual(1.0, float(eval_time_step.reward.mean()), delta=0.3)
def _train(self): for env in self._envs: env.reset() time_step = self._driver.get_initial_time_step() policy_state = self._driver.get_initial_policy_state() iter_num = 0 while True: t0 = time.time() time_step, policy_state, train_steps = self.train_iter( iter_num=iter_num, policy_state=policy_state, time_step=time_step) t = time.time() - t0 logging.log_every_n_seconds(logging.INFO, '%s time=%.3f throughput=%0.2f' % (iter_num, t, int(train_steps) / t), n_seconds=1) tf.summary.scalar("time/train_iter", t) if (iter_num + 1) % self._checkpoint_interval == 0: self._save_checkpoint() if self._evaluate and (iter_num + 1) % self._eval_interval == 0: self._eval() if iter_num == 0: # We need to wait for one iteration to get the operative args # Right just give a fixed gin file name to store operative args common.write_gin_configs(self._root_dir, "configured.gin") with tf.summary.record_if(True): common.summarize_gin_config() tf.summary.text('commandline', ' '.join(sys.argv)) tf.summary.text('optimizers', self._algorithm.get_optimizer_info()) # check termination env_steps_metric = self._driver.get_step_metrics()[1] total_time_steps = env_steps_metric.result().numpy() iter_num += 1 if (self._num_iterations and iter_num >= self._num_iterations) \ or (self._num_env_steps and total_time_steps >= self._num_env_steps): break
def Do(self): """One iteration of the infinite loop.""" lap = None lap_number_und_duration = None point = None try: if not self.timescale_conn: self.timescale_conn = GetConnWithPointPrepare() lap = self.GetLapFromQueue() lap_number_und_duration = self.GetLapDurationFromQueue() point_und_lap_number = self.GetPointFromQueue() if point_und_lap_number: with self.timescale_conn.cursor() as cursor: self.ExportSession(cursor) if lap: self.ExportLap(lap, cursor) if lap_number_und_duration: self.UpdateLapDuration(lap_number_und_duration[0], lap_number_und_duration[1], cursor) self.ExportPoint(point_und_lap_number[0], point_und_lap_number[1], cursor) self._Commit() except psycopg2.Error: stack_trace = ''.join(traceback.format_exception(*sys.exc_info())) logging.log_every_n_seconds( logging.ERROR, 'Error writing to timescale database\n%s', 10, stack_trace) # Repopulate queues on errors. if lap: self.lap_queue.put(lap) if lap_number_und_duration: self.lap_duration_queue.put(lap_number_und_duration) if point: self.retry_point_queue.append(point_und_lap_number) self.timescale_conn = None # Reset connection
def render_image(state, rays_dict, model_fn, device_count, rng, chunk=8192, default_ret_key=None): """Render all the pixels of an image (in test mode). Args: state: model_utils.TrainState. rays_dict: dict, test example. model_fn: function, jit-ed render function. device_count: The number of devices to shard batches over. rng: The random number generator. chunk: int, the size of chunks to render sequentially. default_ret_key: either 'fine' or 'coarse'. If None will default to highest. Returns: rgb: jnp.ndarray, rendered color image. depth: jnp.ndarray, rendered depth. acc: jnp.ndarray, rendered accumulated weights per pixel. """ h, w = rays_dict['origins'].shape[:2] rays_dict = tree_util.tree_map(lambda x: x.reshape((h * w, -1)), rays_dict) num_rays = h * w _, key_0, key_1 = jax.random.split(rng, 3) key_0 = jax.random.split(key_0, device_count) key_1 = jax.random.split(key_1, device_count) host_id = jax.process_index() ret_maps = [] start_time = time.time() num_batches = int(math.ceil(num_rays / chunk)) for batch_idx in range(num_batches): ray_idx = batch_idx * chunk logging.log_every_n_seconds(logging.INFO, 'Rendering batch %d/%d (%d/%d)', 2.0, batch_idx, num_batches, ray_idx, num_rays) # pylint: disable=cell-var-from-loop chunk_slice_fn = lambda x: x[ray_idx:ray_idx + chunk] chunk_rays_dict = tree_util.tree_map(chunk_slice_fn, rays_dict) num_chunk_rays = chunk_rays_dict['origins'].shape[0] remainder = num_chunk_rays % device_count if remainder != 0: padding = device_count - remainder # pylint: disable=cell-var-from-loop chunk_pad_fn = lambda x: jnp.pad(x, ((0, padding), (0, 0)), mode='edge') chunk_rays_dict = tree_util.tree_map(chunk_pad_fn, chunk_rays_dict) else: padding = 0 # After padding the number of chunk_rays is always divisible by # host_count. per_host_rays = num_chunk_rays // jax.process_count() chunk_rays_dict = tree_util.tree_map( lambda x: x[(host_id * per_host_rays): ((host_id + 1) * per_host_rays)], chunk_rays_dict) chunk_rays_dict = utils.shard(chunk_rays_dict, device_count) model_out = model_fn(key_0, key_1, state.optimizer.target['model'], chunk_rays_dict, state.warp_extra) if not default_ret_key: ret_key = 'fine' if 'fine' in model_out else 'coarse' else: ret_key = default_ret_key ret_map = jax_utils.unreplicate(model_out[ret_key]) ret_map = jax.tree_map(lambda x: utils.unshard(x, padding), ret_map) ret_maps.append(ret_map) ret_map = jax.tree_multimap(lambda *x: jnp.concatenate(x, axis=0), *ret_maps) logging.info('Rendering took %.04s', time.time() - start_time) out = {} for key, value in ret_map.items(): out[key] = value.reshape((h, w, *value.shape[1:])) return out
def test_sac_algorithm(self, use_parallel_network, reward_dim): num_env = 1 config = TrainerConfig( root_dir="dummy", unroll_length=1, mini_batch_length=2, mini_batch_size=64, initial_collect_steps=500, whole_replay_buffer_training=False, clear_replay_buffer=False, num_envs=1, ) env_class = PolicyUnittestEnv steps_per_episode = 13 env = env_class(num_env, steps_per_episode, action_type=ActionType.Continuous, reward_dim=reward_dim) eval_env = env_class(100, steps_per_episode, action_type=ActionType.Continuous, reward_dim=reward_dim) obs_spec = env._observation_spec action_spec = env._action_spec fc_layer_params = (10, 10) continuous_projection_net_ctor = partial( alf.networks.NormalProjectionNetwork, state_dependent_std=True, scale_distribution=True, std_transform=clipped_exp) actor_network = partial( ActorDistributionNetwork, fc_layer_params=fc_layer_params, continuous_projection_net_ctor=continuous_projection_net_ctor) critic_network = partial(CriticNetwork, output_tensor_spec=env.reward_spec(), joint_fc_layer_params=fc_layer_params) alg = SacAlgorithm(observation_spec=obs_spec, action_spec=action_spec, actor_network_cls=actor_network, critic_network_cls=critic_network, use_parallel_network=use_parallel_network, use_entropy_reward=reward_dim == 1, env=env, config=config, actor_optimizer=alf.optimizers.Adam(lr=1e-2), critic_optimizer=alf.optimizers.Adam(lr=1e-2), alpha_optimizer=alf.optimizers.Adam(lr=1e-2), debug_summaries=False, name="MySAC") eval_env.reset() for i in range(700): alg.train_iter() if i < config.initial_collect_steps: continue eval_env.reset() eval_time_step = unroll(eval_env, alg, steps_per_episode - 1) logging.log_every_n_seconds( logging.INFO, "%d reward=%f" % (i, float(eval_time_step.reward.mean())), n_seconds=1) self.assertAlmostEqual(1.0, float(eval_time_step.reward.mean()), delta=0.3)
def prediction_step(sess, dataset, dataset_type, model, transition_params_trained, stats_graph_folder, epoch_number, parameters, dataset_filepaths): """ Predict. """ if dataset_type == 'deploy': print('Predict labels for the {0} set'.format(dataset_type)) else: print('Evaluate model on the {0} set'.format(dataset_type)) all_predictions = [] all_y_true = [] output_filepath = os.path.join(stats_graph_folder, '{1:03d}_{0}.txt'.format(dataset_type, epoch_number)) output_file = codecs.open(output_filepath, 'w', 'UTF-8') original_conll_file = codecs.open(dataset_filepaths[dataset_type], 'r', 'UTF-8') res = [None] * len(dataset.token_indices[dataset_type]) def step(start, end): for i in range(start, end): token_indices_sequence = dataset.token_indices[dataset_type][i] feed_dict = { model.input_token_indices: token_indices_sequence, model.input_leading_spaces: dataset.leading_spaces[dataset_type][i], model.input_capitalization: model.InputCapitalization.create_columns(map(dataset.index_to_token.get, token_indices_sequence)), model.input_token_character_indices: dataset.character_indices_padded[dataset_type][i], model.input_token_lengths: dataset.token_lengths[dataset_type][i], model.input_label_indices_vector: dataset.label_vector_indices[dataset_type][i], model.dropout_keep_prob: 1., model.recall_inference_bias: parameters['recall_inference_bias'] if not parameters['train_model'] else 0.0, } res[i] = unary_scores, predictions = sess.run([model.unary_scores, model.predictions], feed_dict) logging.log_every_n_seconds(logging.INFO, 'Predict... run model [{dataset}] {percent}%'.format(dataset=dataset_type ,percent=round(100*i/len(dataset.token_indices[dataset_type]), ndigits=1)), n_seconds=10) chunk_size = min(1, int(len(res) / parameters['number_of_cpu_threads_prediction'])) threads = [threading.Thread(target=step, args=(i, min(len(res), i+chunk_size))) for i in range(0, len(res), chunk_size)] for t in threads: while True: try: t.start() except RuntimeError as e: logging.warning('RuntimeError: can\'t start new thread ######## threading.active_count=%d'% (threading.active_count(),) ) time.sleep(3) continue else: break for t in threads: t.join() del t del threads for i in range(len(dataset.token_indices[dataset_type])): unary_scores, predictions = res[i] if parameters['use_crf']: predictions, _ = tf.contrib.crf.viterbi_decode(unary_scores, transition_params_trained) predictions = predictions[1:-1] else: predictions = predictions.tolist() assert(len(predictions) == len(dataset.tokens[dataset_type][i])) output_string = '' prediction_labels = [dataset.index_to_label[prediction] for prediction in predictions] unary_score_list = unary_scores.tolist()[1:-1] gold_labels = dataset.labels[dataset_type][i] if parameters['tagging_format'] == 'bioes': prediction_labels = utils_nlp.bioes_to_bio(prediction_labels) gold_labels = utils_nlp.bioes_to_bio(gold_labels) for prediction, token, gold_label, scores in zip(prediction_labels, dataset.tokens[dataset_type][i], gold_labels, unary_score_list): while True: line = original_conll_file.readline() split_line = line.strip().split(' ') if '-DOCSTART-' in split_line[0] or len(split_line) == 0 \ or len(split_line[0]) == 0: continue else: token_original = split_line[0] if parameters['tagging_format'] == 'bioes': split_line.pop() gold_label_original = split_line[-1] assert(token == token_original and gold_label == gold_label_original) break split_line.append(prediction) try: if parameters['output_scores']: # space separated scores scores = ' '.join([str(i) for i in scores]) split_line.append('{}'.format(scores)) except KeyError: pass output_string += ' '.join(split_line) + '\n' output_file.write(output_string+'\n') all_predictions.extend(predictions) all_y_true.extend(dataset.label_indices[dataset_type][i]) logging.log_every_n_seconds(logging.INFO, 'Predict... eval [{dataset}] {percent}%'.format(dataset=dataset_type ,percent=round(100*i/len(dataset.token_indices[dataset_type]), ndigits=1)), n_seconds=10) output_file.close() original_conll_file.close() if dataset_type != 'deploy': if parameters['main_evaluation_mode'] == 'conll': # run perl evaluation script in python package # conll_evaluation_script = os.path.join('.', 'conlleval') package_name = 'neuroner' root_dir = os.path.dirname(pkg_resources.resource_filename(package_name, '__init__.py')) conll_evaluation_script = os.path.join(root_dir, 'conlleval') conll_output_filepath = '{0}_conll_evaluation.txt'.format(output_filepath) shell_command = 'perl {0} < {1} > {2}'.format(conll_evaluation_script, output_filepath, conll_output_filepath) os.system(shell_command) with open(conll_output_filepath, 'r') as f: classification_report = f.read() print(classification_report) else: new_y_pred, new_y_true, new_label_indices, new_label_names, _, _ = remap_labels(all_predictions, all_y_true, dataset, parameters['main_evaluation_mode']) print(sklearn.metrics.classification_report(new_y_true, new_y_pred, digits=4, labels=new_label_indices, target_names=new_label_names)) return all_predictions, all_y_true, output_filepath
def _train(self): for env in self._envs: env.reset() if self._eval_env: self._eval_env.reset() begin_iter_num = int(self._trainer_progress._iter_num) iter_num = begin_iter_num checkpoint_interval = math.ceil( (self._num_iterations or self._num_env_steps) / self._num_checkpoints) if self._num_iterations: time_to_checkpoint = self._trainer_progress._iter_num + checkpoint_interval else: time_to_checkpoint = self._trainer_progress._env_steps + checkpoint_interval while True: t0 = time.time() with record_time("time/train_iter"): train_steps = self._algorithm.train_iter() t = time.time() - t0 logging.log_every_n_seconds( logging.INFO, '%s -> %s: %s time=%.3f throughput=%0.2f' % (common.get_gin_file(), [ os.path.basename(self._root_dir.strip('/')) ], iter_num, t, int(train_steps) / t), n_seconds=1) if self._evaluate and (iter_num + 1) % self._eval_interval == 0: self._eval() if iter_num == begin_iter_num: self._summarize_training_setting() # check termination env_steps_metric = self._algorithm.get_step_metrics()[1] total_time_steps = env_steps_metric.result() iter_num += 1 self._trainer_progress.update(iter_num, total_time_steps) if ((self._num_iterations and iter_num >= self._num_iterations) or (self._num_env_steps and total_time_steps >= self._num_env_steps)): # Evaluate before exiting so that the eval curve shown in TB # will align with the final iter/env_step. if self._evaluate: self._eval() break if ((self._num_iterations and iter_num >= time_to_checkpoint) or (self._num_env_steps and total_time_steps >= time_to_checkpoint)): self._save_checkpoint() time_to_checkpoint += checkpoint_interval elif self._checkpoint_requested: logging.info("Saving checkpoint upon request...") self._save_checkpoint() self._checkpoint_requested = False if self._debug_requested: self._debug_requested = False import pdb pdb.set_trace()
def main(argv): point2clusters = collections.defaultdict(list) cluster_dict = dict() logging.info('loading canopy results..') total_num_assignments = process(point2clusters, cluster_dict, FLAGS.input) logging.info('total_num_clusters %s', len(cluster_dict)) logging.info('total_num_assignments %s', total_num_assignments) logging.info('loading canopy results...done') row = np.ones(total_num_assignments, np.int64) col = np.ones(total_num_assignments, np.int64) data = np.ones(total_num_assignments, np.int64) overall_idx = 0 pid2idx = dict() for idx, (pid, clusters) in tqdm(enumerate(point2clusters.items()), 'building sparse graph'): row[overall_idx:overall_idx + len(clusters)] *= idx col[overall_idx:overall_idx + len(clusters)] = np.array(clusters, dtype=np.int64) + len(point2clusters) # import pdb # pdb.set_trace() overall_idx += len(clusters) pid2idx[pid] = idx # import pdb # pdb.set_trace() from scipy.sparse import coo_matrix mat = coo_matrix((data, (row, col)), shape=(len(cluster_dict) + len(point2clusters), len(cluster_dict) + len(point2clusters))) from scipy.sparse.csgraph import connected_components logging.info('running cc...') n_cc, lbl_cc = connected_components(mat, directed=True, connection='weak') logging.info('running cc...done') # import pdb # pdb.set_trace() logging.info('loading mentions...') with open(FLAGS.assignee_name_mentions, 'rb') as fin: assignee_mentions = pickle.load(fin) import uuid final_uuids = [str(uuid.uuid4()) for _ in range(n_cc)] mid2eid = dict() missing_mid2eid = dict() for amid, m in tqdm(assignee_mentions.items(), 'assigning ids'): if m.uuid in pid2idx: for rid in m.mention_ids: logging.log_every_n_seconds(logging.INFO, 'mention: %s -> entity %s', 1, rid, final_uuids[lbl_cc[pid2idx[m.uuid]]]) mid2eid[rid] = final_uuids[lbl_cc[pid2idx[m.uuid]]] else: logging.log_first_n(logging.INFO, 'we didnt do any more diambiguation for %s', 100, m.uuid) for rid in m.mention_ids: missing_mid2eid[rid] = m.uuid logging.info('writing output ...') with open(FLAGS.output, 'w') as fout: for m, e in mid2eid.items(): fout.write('%s\t%s\n' % (m, e)) for m, e in missing_mid2eid.items(): if m not in mid2eid: fout.write('%s\t%s\n' % (m, e)) logging.info('writing output ... done.')
def _test_do_logging(): """Do some log operations.""" logging.vlog(3, 'This line is VLOG level 3') logging.vlog(2, 'This line is VLOG level 2') logging.log(2, 'This line is log level 2') logging.vlog(1, 'This line is VLOG level 1') logging.log(1, 'This line is log level 1') logging.debug('This line is DEBUG') logging.vlog(0, 'This line is VLOG level 0') logging.log(0, 'This line is log level 0') logging.info('Interesting Stuff\0') logging.info('Interesting Stuff with Arguments: %d', 42) logging.info('%(a)s Stuff with %(b)s', { 'a': 'Interesting', 'b': 'Dictionary' }) with mock.patch.object(timeit, 'default_timer') as mock_timer: mock_timer.return_value = 0 while timeit.default_timer() < 9: logging.log_every_n_seconds(logging.INFO, 'This should appear 5 times.', 2) mock_timer.return_value = mock_timer() + .2 for i in xrange(1, 5): logging.log_first_n(logging.INFO, 'Info first %d of %d', 2, i, 2) logging.log_every_n(logging.INFO, 'Info %d (every %d)', 3, i, 3) logging.vlog(-1, 'This line is VLOG level -1') logging.log(-1, 'This line is log level -1') logging.warning('Worrying Stuff') for i in xrange(1, 5): logging.log_first_n(logging.WARNING, 'Warn first %d of %d', 2, i, 2) logging.log_every_n(logging.WARNING, 'Warn %d (every %d)', 3, i, 3) logging.vlog(-2, 'This line is VLOG level -2') logging.log(-2, 'This line is log level -2') try: raise OSError('Fake Error') except OSError: saved_exc_info = sys.exc_info() logging.exception('An Exception %s') logging.exception('Once more, %(reason)s', {'reason': 'just because'}) logging.error('Exception 2 %s', exc_info=True) logging.error('Non-exception', exc_info=False) try: sys.exc_clear() except AttributeError: # No sys.exc_clear() in Python 3, but this will clear sys.exc_info() too. pass logging.error('Exception %s', '3', exc_info=saved_exc_info) logging.error('No traceback', exc_info=saved_exc_info[:2] + (None, )) logging.error('Alarming Stuff') for i in xrange(1, 5): logging.log_first_n(logging.ERROR, 'Error first %d of %d', 2, i, 2) logging.log_every_n(logging.ERROR, 'Error %d (every %d)', 3, i, 3) logging.flush()
def test_off_policy_algorithm(self, algorithm_ctor, use_rollout_state, sync_driver): logging.info("{} {}".format(algorithm_ctor.__name__, sync_driver)) batch_size = 128 if use_rollout_state: steps_per_episode = 5 mini_batch_length = 8 unroll_length = 8 env_class = RNNPolicyUnittestEnv else: steps_per_episode = 12 mini_batch_length = 2 unroll_length = 12 env_class = PolicyUnittestEnv env = TFPyEnvironment( env_class( batch_size, steps_per_episode, action_type=ActionType.Continuous)) eval_env = TFPyEnvironment( env_class( batch_size, steps_per_episode, action_type=ActionType.Continuous)) common.set_global_env(env) algorithm = algorithm_ctor() algorithm.set_summary_settings(summarize_grads_and_vars=True) algorithm.use_rollout_state = use_rollout_state if sync_driver: driver = SyncOffPolicyDriver(env, algorithm) else: driver = AsyncOffPolicyDriver([env], algorithm, num_actor_queues=1, unroll_length=unroll_length, learn_queue_cap=1, actor_queue_cap=1) eval_driver = OnPolicyDriver(eval_env, algorithm, training=False) eval_env.reset() driver.start() if sync_driver: time_step = driver.get_initial_time_step() policy_state = driver.get_initial_policy_state() for i in range(5): time_step, policy_state = driver.run( max_num_steps=batch_size * steps_per_episode, time_step=time_step, policy_state=policy_state) for i in range(500): if sync_driver: time_step, policy_state = driver.run( max_num_steps=batch_size * mini_batch_length * 2, time_step=time_step, policy_state=policy_state) whole_replay_buffer_training = False clear_replay_buffer = False else: driver.run_async() whole_replay_buffer_training = True clear_replay_buffer = True driver.algorithm.train( mini_batch_size=128, mini_batch_length=mini_batch_length, whole_replay_buffer_training=whole_replay_buffer_training, clear_replay_buffer=clear_replay_buffer) eval_env.reset() eval_time_step, _ = eval_driver.run( max_num_steps=(steps_per_episode - 1) * batch_size) logging.log_every_n_seconds( logging.INFO, "%d reward=%f" % (i, float(tf.reduce_mean(eval_time_step.reward))), n_seconds=1) driver.stop() self.assertAlmostEqual( 1.0, float(tf.reduce_mean(eval_time_step.reward)), delta=2e-1)