Ejemplo n.º 1
0
def usage_graph(ex_cfg, explorations, weight_history, title='no title'):
    colors = [graphs.BLUE, graphs.PINK]
    window = 100.0

    uuid_history = tuple(e[0]['uuid'] for e in explorations)
    for i, weights in enumerate(weight_lists):
        ex_uuid = weight_history['ex_uuids'][i]
        ex_name = weight_history['ex_names'][i]

        usage = [t_usage(window, t, ex_uuid, uuid_history) for t in range(len(uuid_history))]
        graphs.perf_std(range(len(usage)), usage, [0.0 for _ in usage], color=colors[i], alpha=0.5,
                          plot_width=1000, plot_height=300, title='usage: {}'.format(title), y_range=(0.0, 1.0))
        graphs.hold(True)

    graphs.hold(False)
Ejemplo n.º 2
0
def coverage_graphs(expcfgs_levels, dest='tmp.html', n_graphs=3):
    cwd = os.getcwd()
    graphs.output_file(dest)

    red = '#DF6464'

    for level in expcfgs_levels:
        for i, exp_cfg in enumerate(level):
            n = 0
            batch = jobfactory.make_jobgroup([exp_cfg])
            os.chdir(os.path.expanduser(exp_cfg.meta.rootpath))

            data_hub = hub.DataHub(batch, sensory_only=True)
            datas = data_hub.data()

            for j, data in enumerate(datas):
                if n_graphs is None or n < n_graphs:
                    for N in [200, 1000]:
                        print(exp_cfg.exploration.explorer)
                        n_reuse = exp_cfg.exploration.explorer.eras[0]
                        s_vectors = [
                            tools.to_vector(s_signal, data.s_channels)
                            for s_signal in data.s_signals
                        ][:N]

                        graphs.coverage(data.s_channels,
                                        exp_cfg.testscov.buffer_size,
                                        s_vectors=s_vectors,
                                        swap_xy=False,
                                        title_text_font_size='6pt',
                                        title='{} {}'.format(
                                            exp_cfg.exp.key, j))
                        graphs.hold(True)
                        graphs.spread(data.s_channels,
                                      s_vectors=s_vectors[n_reuse:],
                                      swap_xy=False,
                                      e_radius=2.0)
                        graphs.hold(True)
                        graphs.spread(data.s_channels,
                                      s_vectors=s_vectors[:n_reuse],
                                      swap_xy=False,
                                      e_radius=2.0,
                                      e_color=red)
                        n += 1

    os.chdir(cwd)
Ejemplo n.º 3
0
def adapt_graphs(ex_cfg, explorations, s_vectors, weight_history, mesh=None, title='no title'):
    s_channels = ex_cfg.s_channels

    tally_dict = {}
    for exploration, feedback in explorations:
        tally_dict.setdefault(exploration['from'], 0)
        tally_dict[exploration['from']] += 1
    print(tally_dict)

    if ex_cfg.div_algorithm == 'hyperball':
        graphs.coverage(s_channels, ex_cfg.threshold, s_vectors=s_vectors, title=title)
    else:
        assert ex_cfg.div_algorithm == 'grid'
        if mesh is not None:
            graphs.mesh(mesh, title=title)
    graphs.hold(True)
    graphs.spread(s_channels, s_vectors=s_vectors, e_radius=1.25, e_alpha=0.75)


    # interest measure
    colors = [graphs.BLUE, graphs.PINK]
    weight_lists = zip(*weight_history['data'])
    for i, weights in enumerate(weight_lists):
        graphs.perf_std(range(len(weights)), weights, [0.0 for _ in weights],
                        legend=weight_history['ex_names'][i], color=colors[i], alpha=0.5,
                        plot_width=1000, plot_height=300, title='diversity: {}'.format(title))
        graphs.hold(True)
    graphs.hold(False)

    # # usage with sliding window
    window = 100.0

    uuid_history = tuple(e[0]['uuid'] for e in explorations)
    for i, weights in enumerate(weight_lists):
        ex_uuid = weight_history['ex_uuids'][i]
        ex_name = weight_history['ex_names'][i]

        usage = [t_usage(window, t, ex_uuid, uuid_history) for t in range(len(uuid_history))]
        graphs.perf_std(range(len(usage)), usage, [0.0 for _ in usage], color=colors[i], alpha=0.5,
                          plot_width=1000, plot_height=300, title='usage: {}'.format(title), y_range=(0.0, 1.0))
        graphs.hold(True)

    graphs.hold(False)
    # print('{} {:.3f}'.format(env_name, np.average(errors)))
    return tally_dict
Ejemplo n.º 4
0
def perf_graphs(sources, targets, mb_steps=200, y_maxs=(360000, 200000)):
    already = False

    for (env_name, ex_name), results in targets.items():
        exp_cfg = results['exp_cfg']

        if not exp_cfg.exp.explorer_name.startswith('reuse.random'):

            if len(exp_cfg.exp.key[1]) != 0:
                if not already:
                    already = False
                    src_results = sources[(exp_cfg.exp.env_name,
                                           'random.goal_{}'.format(mb_steps))]
                    y_max = y_maxs[0] if exp_cfg.exp.env_name.startswith(
                        'dov_ball') else y_maxs[1]
                    graphs.perf_astd(src_results['ticks'],
                                     src_results['avg'],
                                     src_results['astd'],
                                     color=graphs.NOREUSE_COLOR,
                                     plot_width=1000,
                                     plot_height=500,
                                     x_range=(0, exp_cfg.job.steps),
                                     y_range=(0, y_max),
                                     title='{}'.format(exp_cfg.exp.key))
                    graphs.hold(True)

                print('{}::{} {}'.format(exp_cfg.exp.env_name,
                                         exp_cfg.exp.explorer_name,
                                         results['avg'][-1]))
                graphs.bokeh_astds(results['ticks'],
                                   results['avg'],
                                   results['astd'],
                                   color=graphs.REUSE_COLOR)
                graphs.hold(True)

                random_key = randomit(exp_cfg.exp.key)
                if random_key in targets:
                    random_results = targets[random_key]
                    graphs.perf_astd(random_results['ticks'],
                                     random_results['avg'],
                                     random_results['astd'],
                                     color=graphs.RANDREUSE_COLOR)

                graphs.hold(False)
Ejemplo n.º 5
0

for ex_name in ['random.goal']:
    random.seed(0)

    # instanciating the environment
    env_name, env_cfg = envs.kin(dim=DIM, limit=LIMIT)
    env = environments.Environment.create(env_cfg)

    # instanciating the explorer
    ex_cfg = exs.catalog[ex_name]._deepcopy()
    ex_cfg.m_channels = env.m_channels
    ex_cfg.s_channels = env.s_channels
    ex = explorers.Explorer.create(ex_cfg)

    # running exploration
    explorations, s_vectors, s_goals = factored.run_exploration(env, ex, N, verbose=True)

    # making graphs
    for t1, t2 in [(0, 100), (100, N)]:
        alpha = 1.0 if t2 == 100 else 0.25
        graphs.posture_random(env, explorations[t1:t2], n=10,
                              alpha=0.75, radius_factor=0.35)
        graphs.hold(True)
        graphs.bokeh_spread(env.s_channels, s_vectors=s_vectors[:t2],
                            e_radius=1.5, e_alpha=alpha,
                            x_range=(-1.05, 1.05), y_range=(-1.05, 1.05),
                            title='{}::{}'.format(ex_name, env_name))

graphs.show()
Ejemplo n.º 6
0
# Graph of reused effects in first env
s_vectors0 = []
for explo in explorations[:MB]:
    feedback = env0.execute(explo[0]['m_signal'])
    s_vectors0.append(
        explorers.tools.to_vector(feedback['s_signal'], env0.s_channels))

graphs.spread(env.s_channels,
              s_vectors=s_vectors0[:MB],
              e_radius=3.0,
              e_alpha=1.0,
              e_color='#DF6464',
              title='first arm - reused effects')
for e in explorations[:MB]:
    graphs.hold(True)
    graphs.posture_signals(env0, [e[0]['m_signal']],
                           alpha=ARM_ALPHA,
                           radius_factor=0.75)
graphs.hold(True)
graphs.spread(env.s_channels,
              s_vectors=s_vectors0[:MB],
              grid=False,
              e_radius=3.0,
              e_alpha=1.0,
              e_color='#DF6464')
graphs.hold(False)

# Graph Reuse
for t in [MB, 200, 400, N]:
Ejemplo n.º 7
0
                    min_avgs[env_key] = data['avg'][index]
                    min_stds[env_key] = data['std'][index]

    for env_key in env_keys:
        ps[env_key] = sorted(ps[env_key])
        avgs[env_key] = np.array([avgs[env_key][p] for p in ps[env_key]])
        stds[env_key] = np.array([stds[env_key][p] for p in ps[env_key]])

    os.chdir(cwd)

    return env_keys, ps, avgs, stds, min_avgs, min_stds



if __name__ == '__main__':
    env_keys, ps, avgs, stds, min_avgs, min_stds = load_data('nn')

    colors = [graphs.BLUE, graphs.PINK, graphs.GREEN]
    graphs.output_file('fixed_graph.html')

    env_displayed = [env_key for env_key in env_keys if env_key[0] == 'kin20_150' and env_key[2] == 5000]

    for color, envd in zip(colors, env_displayed):
        print(avgs[envd])
        y_max = max(avgs[envd] + stds[envd])
        graphs.perf_std_discrete(ps[envd], avgs[envd], stds[envd], std_width=0.0035, color=color,
                                 y_range=[0.0, y_max+0.02], plot_width=1000, plot_height=500, title='{} {}'.format(*envd))
        graphs.hold(True)

    graphs.show()
Ejemplo n.º 8
0
    for N in Ns:
        index = data['ticks'].index(N)
        adapt_avgs[(d, N)] = data['avg'][index]
        adapt_stds[(d, N)] = data['std'][index]

os.chdir(cwd)


for d in disturbs:
    for N in Ns:
        print('N={}:  {} +- {}'.format(N, adapt_avgs[(d, N)], adapt_stds[(d, N)]))



if __name__ == '__main__':
    graphs.output_file('ddmab_graph.html')
    y_ranges=[(0.075, 0.3), (0.0, 0.1), (0.08, 0.14)]

    for i, d in enumerate(disturbs):
        y_range = y_ranges[i]
        for N in Ns:
            graphs.perf_std_discrete([100*i*0.05 for i in range(21)],
                                     avgs[('kin20_150', d, N)], stds[('kin20_150', d, N)],
                                     std_width=0.25, alpha=0.5, y_range=y_range,
                                     plot_height=300, title='d={} t={}'.format(d, N))
            graphs.hold(True)
            graphs.line([0, 100], adapt_avgs[(d, N)], adapt_stds[(d, N)])
            graphs.hold(False)

    graphs.show()