def popcode(y, resolution): N = y.shape[0] pc = np.zeros((N, resolution), 'float32') for i in range(N): # assert 0 <= y[i] <= 1 # y in [0, 1] x = y[i] * (resolution - 1) # x in [0, res-1] l = np.floor(x) # l in [0, res-1] u = np.ceil(x) # u in [0, res-1] if l == u: pc[i, l] = 1 continue lr = x - l if False: ur = u - x assert_allclose(lr + ur, 1) pc[i, l] = 1 - lr pc[i, u] = lr return pc
def test_encryption(): password = '******' for nbits in [8, 16, 20]: bits = np.round(np.random.rand(nbits)) msg = bits_encrypt(bits, password) bits2 = bits_decrypt(msg, password, len(bits)) assert_allclose(bits, bits2)
def test_popcode_inv(): for _, a, b in examples: b = np.array([b]).astype('float32') a2 = popcode_inv(b) # print(' a = %s' % a) # print('a2 = %s' % a2) # print(' b = %s' % b) assert_allclose(a2[0], a)
def test_popcode(): for resolution, a, b in examples: a = np.array([a]).astype('float32') b2 = popcode(a, resolution) # print(' a = %s' % a) # print(' b = %s' % b) # print('b2 = %s' % b2) assert_allclose(b2[0], b)
def check_scale_score_variants_test(): print('Original scale_score') v = data['v5'] x0 = scale_score(v) check_scale_score(v, x0) for id_algo, algo in algos.items(): print('Variant %s' % id_algo) x = algo(v) check_scale_score(v, x) assert_allclose(x, x0)
def test_popcode1(): resolution = 10 N = 5 for resolution in [2, 5, 10, 20]: a = np.random.rand(N) b = popcode(a, resolution=resolution) a2 = popcode_inv(b) # print('---') # print(' a = %s' % a) # print(' b = %s' % b) # print('a2 = %s' % a2) assert b.shape == (N, resolution) assert a2.shape == a.shape assert_allclose(a2, a)
def check_logs_formats(id_agent, agent, id_robot, robot): # @UnusedVariable with create_tmp_dir() as root: os.mkdir(os.path.join(root, 'config')) data_central = DataCentral(root) # Simulate two episodes # NO! there is a bug in bag reading; the messages are read # in timestamp order; and for now different episodes can # have overlapping timestamps try: simulate(data_central, id_agent=id_agent, id_robot=id_robot, max_episode_len=2, num_episodes=1, # changed from 2 (see above) cumulative=False, id_episodes=None, stateful=False, interval_print=None, write_extra=True) except UnsupportedSpec: return log_index = data_central.get_log_index() log_index.reindex() streams = log_index.get_streams_for(id_robot, id_agent) if len(streams) != 1: msg = 'Expected to find 1 stream, not %d' % len(streams) raise Exception(msg) stream_orig = streams[0] for logs_format, interface in LogsFormat.formats.items(): try: dirname = os.path.join(root, logs_format) safe_makedirs(dirname) filename = os.path.join(dirname, 'example.%s' % logs_format) written = [] id_stream = 'example' with interface.write_stream(filename, id_stream, robot.get_spec()) as writer: for observations in stream_orig.read(): logger.info('Writing %s:%s (%s)' % (observations['id_episode'], observations['counter'], observations['timestamp'])) writer.push_observations(observations) written.append(observations) count = 0 for obs_read in interface.read_from_stream(filename, id_stream): logger.info('Reading %s:%s (%s)' % (obs_read['id_episode'], obs_read['counter'], obs_read['timestamp'])) original = written[count] try: if obs_read['counter'] != original['counter']: msg = ('Not even the counter is the same!' ' %s vs %s' % (obs_read['counter'], original['counter'])) raise Exception(msg) assert_allclose(obs_read['timestamp'], original['timestamp']) assert_allclose(obs_read['observations'], original['observations']) assert_allclose(obs_read['commands'], original['commands']) except: logger.error('Error at count = %d' % count) logger.error(' original: %s' % original) logger.error(' obs_read: %s' % obs_read) raise count += 1 if count != len(written): msg = ('I wrote %d entries, but obtained %d.' % (len(written), count)) raise Exception(msg) except: logger.error('Could not pass tests for format %r.' % logs_format) raise
def check_conversions(stream_spec1, nuisance): # print('Checking %s / %s ' % (stream_spec1, nuisance)) nuisance_inv = None try: try: stream_spec2 = nuisance.transform_spec(stream_spec1) except UnsupportedSpec as e: logger.info('Skipping %s/%s because incompatible: %s' % (stream_spec1, nuisance, e)) return value1 = stream_spec1.get_random_value() stream_spec1.check_valid_value(value1) value2 = nuisance.transform_value(value1) stream_spec2.check_valid_value(value2) try: nuisance_inv = nuisance.inverse() except NuisanceNotInvertible as e: logger.info('Skipping some tests %s/%s because not invertible:' ' %s' % (stream_spec1, nuisance, e)) return try: stream_spec1b = nuisance_inv.transform_spec(stream_spec2) except UnsupportedSpec as e: msg = ('The inverse of the nuisance does not seem to be able ' 'to handle the result:\n%s\n\n' ' stream_spec1: %s\n' ' nuisance: %s\n' ' stream_spec2: %s\n' ' nuisance_inv: %s\n' % (indent(str(e), '>'), stream_spec1.to_yaml(), nuisance, stream_spec2.to_yaml(), nuisance_inv)) raise ValueError(msg) try: StreamSpec.check_same_spec(stream_spec1, stream_spec1b) except Exception as e: msg = ('The inverse of the nuisance does not recreate the ' 'initial spec:\n%s\n\n' ' stream_spec1: %s\n' ' nuisance: %s\n' ' stream_spec2: %s\n' ' nuisance_inv: %s\n' ' stream_spec1b: %s\n' % (indent(str(e), '>'), stream_spec1.to_yaml(), nuisance, stream_spec2.to_yaml(), nuisance_inv, stream_spec1b.to_yaml())) raise ValueError(msg) value1b = nuisance_inv.transform_value(value2) stream_spec1.check_valid_value(value1b) # TODO: if exact assert_allclose(value1, value1b, rtol=1e-5) except: logger.error('Error while testing:') logger.error(' stream_spec: %s ' % stream_spec1.to_yaml()) logger.error(' nuisance: %s' % nuisance) logger.error(' nuisance_inv: %s' % nuisance_inv) raise
def check_gray_code(code): for i in range(len(code) - 1): w1 = code[i] w2 = code[i + 1] dist = np.sum(np.abs(w1 - w2)) assert_allclose(dist, 1)
def scipy_image_resample_test4(self): """ Resampling should be invertible if using order = 0 """ a = np.random.rand(10, 10).astype('float32') b = scipy_image_resample(a, (20, 20), order=0) a1 = scipy_image_resample(b, (10, 10), order=0) assert_allclose(a1, a)
def check_cmdline(id_agent, agent, id_robot, robot): # @UnusedVariable try: agent.init(robot.get_spec()) except UnsupportedSpec: return with create_tmp_dir() as root: os.mkdir(os.path.join(root, 'config')) # XXX make it automatic data_central = DataCentral(root) log_index = data_central.get_log_index() def execute_command(*args): arguments = ['-d', root, '--contracts'] + list(args) boot_olympics_manager(arguments) assert not log_index.has_streams_for_robot(id_robot) formats = LogsFormat.formats.keys() for logs_format in formats: execute_command('--logformat', logs_format, 'simulate', '-a', id_agent, '-r', id_robot, '--num_episodes', '2', '--episode_len', '2') execute_command('--logformat', logs_format, 'simulate', '-a', id_agent, '-r', id_robot, '--num_episodes', '2', '--episode_len', '2') assert not log_index.has_streams_for_robot(id_robot) log_index.reindex() assert log_index.has_streams_for_robot(id_robot) n = len(formats) assert_allclose(len(log_index.get_streams_for_robot(id_robot)), 2 * n) assert_allclose(len(log_index.get_streams_for(id_robot, id_agent)), 2 * n) assert_allclose(len(log_index.get_episodes_for_robot(id_robot)), 4 * n) assert_allclose(len(log_index.get_episodes_for_robot(id_robot, id_agent)), 4 * n) execute_command('learn-log', '-a', id_agent, '-r', id_robot) try: agent.get_servo() except NotImplementedError: pass else: execute_command('servo', '-a', id_agent, '-r', id_robot, '--num_episodes', '1', '--max_episode_len', '1') try: agent.get_predictor() except NotImplementedError: pass else: execute_command('predict', '-a', id_agent, '-r', id_robot) execute_command('list-logs') execute_command('list-logs', '-e') execute_command('list-logs', '-l') execute_command('list-logs', '-s') execute_command('list-logs', '-R') # TODO: publish # execute_command('batch') # TODO: test batch execute_command('list-agents') execute_command('list-agents', '-v') execute_command('list-robots') execute_command('list-robots', '-v') execute_command('list-states') execute_command('list-states', '-v')