Python reprep.Report类代码示例

def fairness_table(all_results):
        
    cols_desc = [' ID', 'Length (min)', 'Num. saccades', 'saccades/s',
                 'p_L', 'p value', 'rejected']
    rows = []     
    for i, results in enumerate(all_results):
        results = dict(results)
        
        rejected = {True:'*', False:''}[results['fair_rejected']]
        row = [i,
               "%.1f" % (results['length'] / 60),
               results['N'],
               "%.2f" % results['density'],
               "%.2f" % results['p_L'],
               "%.3f" % results['fair_pvalue'],
               rejected]

        rows.append(row)

    # caption = get_nice_dataset_description(dataset)
    print rows
    
    # sort by length
    rows.sort(key=lambda x:-float(x[1]))
    
    r = Report()
    attach_description(r, description)
    r.table('fairness', rows, cols=cols_desc)
    return r

def report_statistics(id_sub, stats):
    records = stats['records']
    distance = records['distance']
    delta = records['delta']
    order = scale_score(distance)
    order = order / float(order.size)

    r = Report('stats-%s' % id_sub)
    r.data('records', records)
    f = r.figure()
    
    with f.plot('scatter') as pylab:
        pylab.scatter(delta, distance)
        pylab.xlabel('delta')
        pylab.ylabel('distance')
        pylab.axis((-1, np.max(delta) + 1, -0.05, np.max(distance)))
        
    with f.plot('with_stats', **dp_predstats_fig) as pylab:
        fancy_error_display(pylab, delta, distance, 'g')

    with f.plot('distance_order', **dp_predstats_fig) as pylab:
        fancy_error_display(pylab, delta, order, color='k')
        
    f = r.figure(cols=1)        
    bins = np.linspace(0, np.max(distance), 100)
    for i, d in enumerate(set(delta)):
        with f.plot('conditional%d' % i) as pylab:
            which = delta == d
            pylab.hist(distance[which], bins)

    return r

 def set_goal_observations(self, goal):
     self.goal = self.obs2ui(goal)        
     self.a_pred = [a.predict(self.goal) for a in self.actions_i]
     
     r = Report('set_goal_observations')
     self.report(r)
     r.to_html('set_goal_observations.html')

def sample_var_hist(sample, expdata, configuration, #@UnusedVariable
                    saccades, variable):
    lb = variable.interesting[0]
    ub = variable.interesting[1]
    
    x = saccades[variable.field]
    if variable.mod:
        M = variable.interesting[1]
        x = numpy.fmod(x + M, M)
    
    # TODO: we don't strictly enforce the bounds and we do not compute
    # how many are left out
    hist, bin_edges = numpy.histogram(x, bins=variable.density_bins,
                range=variable.interesting, normed=True)

    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
     
    r = Report()
    attach_description(r, description.format(var=variable, ub=ub, lb=lb))
    with r.data_pylab('histogram') as pylab:
        pylab.plot(bin_centers, hist, 'b-')
        
        pylab.ylabel('density')
        pylab.xlabel('%s (%s)' % (variable.name, variable.unit))
        
        pylab.axis([lb, ub, 0, variable.density_max_y])
    return r

        def go():
            string = request.params['string'].encode('utf-8')
            nl = int(request.params['nl'])
            nu = int(request.params['nu'])
            key = (string, nl, nu)
            s = self.solutions[key]

            result_l = s['result_l']
            result_u = s['result_u']
            # print result_l, result_u
            dpl = s['dpl']
            _dpu = s['dpu']

            R = dpl.get_res_space()
            UR = UpperSets(R)
            r = Report()
            f = r.figure()
            plotter = get_best_plotter(space=UR)
            # print plotter
            # generic_plot(f, space=UR, value=result_l)

            axis = plotter.axis_for_sequence(UR, [result_l, result_u])

            with f.plot("plot") as pylab:
                plotter.plot(pylab, axis, UR, result_l,
                             params=dict(markers='g.', color_shadow='green'))
                plotter.plot(pylab, axis, UR, result_u,
                             params=dict(markers='b.', color_shadow='blue'))


            png_node = r.resolve_url('png')
            png_data = png_node.get_raw_data()

            return response_data(request=request, data=png_data,
                                 content_type='image/png')

def report_summary(results):
    # results = tuple (name, res dict)
    r = Report()

    cols = ['scenario', 'number of bits', 'number of states']
    data = []
    for name, res in results:
        
        agent = res['agent']
        
        nstates = len(agent.get_all_states())
        nbits = agent.get_num_states_components()
        row = [name, nbits, nstates]
        data.append(row)

    r.table('summary', data=data, cols=cols)
        

    cols = [ 'number of bits', 'number of states']
    data = []
    rows = []
    for name, res in results:

        agent = res['agent']

        nstates = len(agent.get_all_states())
        nbits = agent.get_num_states_components()
        rows.append(name)
        data.append([nbits, nstates])

    r.table('summary2', data=data, cols=cols, rows=rows)


    return r

def interval_histogram(group, configuration, saccades):    #@UnusedVariable
    interval = saccades[:]['time_passed']

    edges = (2.0 ** numpy.array(range(1, 21))) / 1000
    # centers = (edges[1:]+edges[:-1])/2
    h, edges_ = numpy.histogram(interval, bins=edges, normed=True) #@UnusedVariable
    
    bin_width = numpy.diff(edges);
    hn = h / bin_width;
    
    print 'h', h
    print 'hn', hn
    print 'edges', edges
    print 'width', bin_width
                                
    r = Report()
    attach_description(r, description)
    
    node_id = 'inthist'
    with r.data_pylab(node_id) as pylab:
        pylab.loglog(bin_width, h, 'x-')
        pylab.title('not normalized')
        pylab.xlabel('interval bin width (s)')
        pylab.ylabel('density (s)')
        
    node_id = 'inthistn'
    with r.data_pylab(node_id) as pylab:
        pylab.loglog(bin_width, hn, 'x-')
        pylab.title('normalized by bin width')
        pylab.xlabel('interval bin width (s)')
        pylab.ylabel('density (s)')
        
        
    return r

def create_report(subsets):
    report = Report('tammero_analysis')
    for id, desc, saccades in subsets:
        # XXX temporary
        report.add_child(create_report_subset(id, desc, saccades))
        report.add_child(create_report_randomness(id, desc, saccades))
    return report

def report_results_single(func, objspec_name, results):

    def get_string_result(res):
        if res is None:
            s = 'ok'
        elif isinstance(res, Skipped):
            s = 'skipped'
        elif isinstance(res, PartiallySkipped):
            parts = res.get_skipped_parts()
            s = 'no ' + ','.join(parts)
        else:
            print('how to interpret %s? ' % describe_value(res))
            s = '?'
        return s

    r = Report()
    if not results:
        r.text('warning', 'no test objects defined')
        return r

    rows = []
    data = []
    for id_object, res in list(results.items()):
        rows.append(id_object)

        data.append([get_string_result(res)])

    r.table('summary', rows=rows, data=data)
    return r

def go():
    ieee_fonts_zoom3(pylab)

    r = Report()
    algos = [InvMult2.ALGO_UNIFORM, InvMult2.ALGO_VAN_DER_CORPUT]
    for algo in algos:
        InvMult2.ALGO = algo
        InvPlus2.ALGO = algo
        print("Using algorithm %s " % algo)
        with r.subsection(algo) as r2:
            # first
            F = parse_poset("dimensionless")
            R = F
            dp = InvMult2(F, (R, R))
            ns = [3, 4, 5, 6, 10, 15]

            axis = (0.0, 6.0, 0.0, 6.0)

            with r2.subsection("invmult2") as rr:
                go1(rr, ns, dp, plot_nominal_invmult, axis)

            # second
            axis = (0.0, 1.2, 0.0, 1.2)
            dp = InvPlus2(F, (R, R))
            with r2.subsection("invplus2") as rr:
                go1(rr, ns, dp, plot_nominal_invplus, axis)

    fn = "out-plot_approximations/report.html"
    print("writing to %s" % fn)
    r.to_html(fn)

def report_vit(mdp, vit_res):
    r = Report()

    f = r.figure()
    with f.plot('value') as pylab:
        mdp.display_state_values(pylab, vit_res)
    return r

def group_var_hist(group, configuration, saccades, variable): #@UnusedVariable
    lb = variable.interesting[0]
    ub = variable.interesting[1]
    
    x = saccades[variable.field]
    
    if variable.mod:
        M = variable.interesting[1]
        x = numpy.fmod(x + M, M)

    hist, bin_edges = numpy.histogram(x, bins=variable.density_bins,
                range=variable.interesting, normed=True)

    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
    
    r = Report()
    attach_description(r, description.format(var=variable, ub=ub, lb=lb))

    with r.data_pylab('histogram') as pylab:
        pylab.plot(bin_centers, hist, 'b-')
        
        pylab.ylabel('density')
        pylab.xlabel('%s (%s)' % (variable.name, variable.unit))
        
        pylab.axis([lb, ub, 0, variable.density_max_y])
        
    return r

def report_distances2_global(combs, explogs_test, arrows, interps):
    r = Report()
    figs = {}
    
    def get_fig(id_robot):
        if not id_robot in figs:
            figs[id_robot] = r.figure(cols=len(explogs_test), caption=id_robot)
        return figs[id_robot]
    
    for id_robot, id_agent in combs:

        for id_episode in map(str, explogs_test):
            key = dict(id_robot=id_robot, id_agent=id_agent, id_episode=id_episode)
            interp = interps[key]
            interp.nid = basename_from_key(key) + '-interp'
            interp.caption = '%s, %s' % (id_robot, id_agent)
            r.add_child(interp)
            get_fig(id_robot).sub(interp)

        for id_episode in map(str, explogs_test):
            key = dict(id_robot=id_robot, id_agent=id_agent, id_episode=id_episode)
            arrow = arrows[key]
            arrow.nid = basename_from_key(key) + '-vf'
            arrow.caption = '%s, %s' % (id_robot, id_agent)
            r.add_child(arrow)
            get_fig(id_robot).sub(arrow)

    return r

def render_page(view2result, outdir, page_id):

    def iterate_views():
        for view in views: 
            yield view, view2result[view.id]
            
    # first compute max value
    mean_max = max(map(lambda x: numpy.max(x[1].mean), iterate_views()))
    var_max = max(map(lambda x: numpy.max(x[1].var), iterate_views()))
             
    n = Report(page_id)
    f = n.figure(cols=3)
    for view, stats in iterate_views():
        nv = n.node(view.id)
        add_scaled(nv, 'mean', stats.mean, max_value=mean_max)
        add_scaled(nv, 'var', stats.var, max_value=var_max)
        #add_scaled(nv, 'min', stats.min)
        #add_scaled(nv, 'max', stats.max)
    
    for view in views:
        what = 'mean'
    #for what, view in prod(['mean', 'var'], views):
        f.sub('%s/%s' % (view.id, what),
              caption='%s (%s)' % (view.desc, what))
    
    output_file = os.path.join(outdir, '%s.html' % n.id)
    resources_dir = os.path.join(outdir, 'images')
    print "Writing to %s" % output_file
    n.to_html(output_file, resources_dir=resources_dir)

def simple_plots(d):
    # TO
    y_cov = d.y_cov
    y_dot_cov = d.y_dot_cov
    y_dot_sign_cov = d.y_dot_sign_cov
    
    vars = [ ('y', y_cov, {}),
             ('y_dot', y_dot_cov, {}),
             ('y_dot_sign', y_dot_sign_cov, {}) ] 
#
#    I = numpy.eye(y_cov.shape[0])
#    
    r = Report()
    f = r.figure(cols=3)
    for var in vars:
        label = var[0]
        cov = var[1]
        corr = cov2corr(cov, zero_diagonal=False)
        corr_z = cov2corr(cov, zero_diagonal=True)
        
        n1 = r.data("cov_%s" % label, cov).display('posneg')
        n2 = r.data("corr_%s" % label, corr).display('posneg')
        n3 = r.data("corrz_%s" % label, corr_z).display('posneg')
        
        f.sub(n1, 'Covariance of %s' % label)
        f.sub(n2, 'Correlation of %s ' % label)
        f.sub(n3, 'Correlation of %s (zeroing diagonal)' % label)
        
    return r