예제 #1
0
 def table(self):
     configuration = self.graph.getConfiguration()
     sanitise = lambda x:str(util.ci(x))
     # Include those variables which vary in the graph.
     headingkeys = [ x for x in config.configvariables.keys() \
                     if x not in configuration.keys() ]
     # Create a row for each data point.
     rows = []
     for x in self.graph.data:
         heading = [ "%s %s" % (util.ci(getattr(x, k)), config.configvariables[k]) \
                      for k in headingkeys ]
         heading = string.join(heading)
         colour = (x.better() and "green") or \
                  (x.significant() and "red") or "white"
         row = TABLEROW % (colour,
                           heading,
                           x.productdata.mean,
                           x.productdata.count,
                           x.referencedata.mean,
                           x.referencedata.count,
                           x.relative)
         row = re.sub("_", "\_", row)
         rows.append(row)
     rows = string.join(rows, "\\\\ \hline\n")
     rows += "\\\\ \hline\n"
     return TABLE % rows
예제 #2
0
def average_froc_with_ci(frocs, fppi_range, confidence=0.95):
    av_sen = []

    for i in range(len(frocs)):
        x = frocs[i].T
        f = interp1d(x[0],
                     x[1],
                     kind='linear',
                     fill_value=0.0,
                     bounds_error=False)
        sen = f(fppi_range)
        av_sen.append(sen)

    av_sen = np.array(av_sen)
    assert len(fppi_range) == len(av_sen[i])

    aucs = []
    for i in range(len(av_sen)):
        froc = np.array([fppi_range, av_sen[i]]).T
        aucs.append(util.auc(froc, fppi_range))

    lo, up = util.ci(aucs, confidence)

    av_froc = [fppi_range, np.mean(av_sen, axis=0), np.std(av_sen, axis=0)]
    av_froc = np.array(av_froc).T

    return av_froc, lo, up
예제 #3
0
파일: format.py 프로젝트: johnmdilley/xenrt
    def create(self):
        self.figure = matplotlib.pyplot.figure()
        axis = self.figure.add_subplot(1, 1, 1)

        errorvalues = [x.error for x in self.data]
        productvalues = [x.productdata.mean for x in self.data]
        referencevalues = [x.referencedata.mean for x in self.data]
        index = numpy.arange(len(productvalues))

        # Work out the colours to use for the product bars.
        colours = []
        for x in self.data:
            if x.better():
                colours.append(self.bettercolour)
            elif x.significant():
                colours.append(self.worsecolour)
            else:
                colours.append(self.colour)

        # Plot the product bars.
        axis.bar(
            index,
            productvalues,
            self.width,
            yerr=errorvalues,
            color=colours,
            ecolor=self.errorcolour,
            linewidth=self.linewidth,
        )
        # Plot the reference bars next to the product bars.
        axis.bar(
            index + self.width,
            referencevalues,
            self.width,
            color=self.referencecolour,
            ecolor=self.errorcolour,
            linewidth=self.linewidth,
        )

        # Set the axes' ranges.
        axis.set_ylim(ymin=0)

        # Spruce the graph up a bit.
        xlabels = [
            string.join(["%s %s" % (util.ci(getattr(x, y)), config.configvariables[y]) for y in config.bars], "\n")
            for x in self.data
        ]
        axis.set_xticklabels(xlabels, size=self.labelpointsize)
        axis.set_xticks(index + self.width)
        axis.set_ylabel(self.data[0].units)
        for x in axis.get_ymajorticklabels():
            x.set_size(self.labelpointsize)
        axis.set_clip_on(False)
예제 #4
0
파일: format.py 프로젝트: thomassa/xenrt
    def create(self):
        self.figure = matplotlib.pyplot.figure()
        axis = self.figure.add_subplot(1, 1, 1)

        errorvalues = [x.error for x in self.data]
        productvalues = [x.productdata.mean for x in self.data]
        referencevalues = [x.referencedata.mean for x in self.data]
        index = numpy.arange(len(productvalues))

        # Work out the colours to use for the product bars.
        colours = []
        for x in self.data:
            if x.better(): colours.append(self.bettercolour)
            elif x.significant(): colours.append(self.worsecolour)
            else: colours.append(self.colour)

        # Plot the product bars.
        axis.bar(index,
                 productvalues,
                 self.width,
                 yerr=errorvalues,
                 color=colours,
                 ecolor=self.errorcolour,
                 linewidth=self.linewidth)
        # Plot the reference bars next to the product bars.
        axis.bar(index + self.width,
                 referencevalues,
                 self.width,
                 color=self.referencecolour,
                 ecolor=self.errorcolour,
                 linewidth=self.linewidth)

        # Set the axes' ranges.
        axis.set_ylim(ymin=0)

        # Spruce the graph up a bit.
        xlabels = [ string.join([ "%s %s" % (util.ci(getattr(x, y)), config.configvariables[y]) \
                        for y in config.bars ], "\n") \
                            for x in self.data ]
        axis.set_xticklabels(xlabels, size=self.labelpointsize)
        axis.set_xticks(index + self.width)
        axis.set_ylabel(self.data[0].units)
        for x in axis.get_ymajorticklabels():
            x.set_size(self.labelpointsize)
        axis.set_clip_on(False)
예제 #5
0
 def include(self, level=""):
     level = "sub" * len(config.documentsections)
     configuration = self.graph.getConfiguration()
     # Function to clean up the config strings.
     sanitise = lambda x:str(util.ci(x))
     caption = [] 
     for k in config.displayorder:
         if not configuration.has_key(k):
             continue
         configuration[k] = sanitise(configuration[k])
         # Don't repeat information in the report.
         #if not k in config.documentsections:
         caption.append("%s %s" % (string.upper(str(configuration[k])),
                                   config.configvariables[k]))
     caption = string.join(caption)
     caption = re.sub("_", "-", caption)
     return INCLUDE % (level,
                       caption, 
                       self.graph.filename, 
                       self.path, 
                       self.graph.filename, 
                       caption, 
                       self.path, 
                       self.graph.filename)
def perf_measure_1():
    # 1. For individual vehicles: distribution of the travel time (mean, standard deviation, plot
    # a histogram). Indicate which part of the travel time is caused by the delay. Present
    # results on the number of incidents they encounter on average (again: mean, standard
    # deviation, distribution).

    # Travel time on the route between A to B
    # Probability of minutes of time taken for the travel along the route. Ghost cars not necessary, or included.
    graph_type = 'Highway'
    system = run_simulation('Measure-1',
                            seed=30,
                            end_time=1600,
                            stats_step_size=50,
                            graph_type=graph_type,
                            tow_truck_mode=False,
                            warm_up=100)
    travel_times_list = system.final_statistics['route_travel_times']
    delay_times_list = system.final_statistics['route_delay_times']
    number_delays_list = system.final_statistics['route_number_delays']
    print('Travel Times List for Route Cars')
    print(travel_times_list)
    print(len(travel_times_list))

    # Graph 1
    rounded_travel_times_list = [round(i) for i in travel_times_list]
    max_travel_time = max(rounded_travel_times_list)
    counts_travel_times = Counter(rounded_travel_times_list)
    list_of_times = []
    print('Rounded Travel Times List', rounded_travel_times_list)
    for i in range(int(max_travel_time) + 1):
        list_of_times.append(counts_travel_times[i])
    print(list_of_times)  # Must be X-axis
    print('Count of travel times -', list_of_times)
    plot = plt.figure()
    plt.ylabel('Probability')
    plt.xlabel('Total Travel Time')
    plt.xlim(50, max_travel_time)
    plt.plot([i for i in range(len(list_of_times))],
             [j / sum(list_of_times) for j in list_of_times])
    plt.show()

    # Graph 2
    rounded_delay_times_list = [round(i) for i in delay_times_list]
    max_delay_time = max(rounded_delay_times_list)
    counts_delay_times = Counter(rounded_delay_times_list)
    list_of_delay_times = []
    print('Rounded Delay Times List', rounded_delay_times_list)
    for i in range(1, int(max_delay_time) + 1):
        list_of_delay_times.append(counts_delay_times[i])
    print(list_of_delay_times)  # Must be X-axis
    print('Count of delay times -', list_of_delay_times)
    plot = plt.figure()
    plt.ylabel('Probability')
    plt.xlabel('Total Delay Time')
    plt.xlim(1, max_delay_time)
    plt.plot([i for i in range(len(list_of_delay_times))],
             [j / sum(list_of_delay_times) for j in list_of_delay_times])
    plt.show()

    # Graph 3
    # Showing the distribution of the number of incidents in a single route travel
    print(number_delays_list)
    counts_number_delays = Counter(number_delays_list)
    list_of_number_delays = []
    for i in range(max(number_delays_list) + 1):
        list_of_number_delays.append(counts_number_delays[i])
    print('Counts of number of delays', list_of_number_delays)
    plot = plt.figure()
    plt.xlabel('Numbers of incidents')
    plt.ylabel('Probability')
    # plt.xlim(1, max_delay_time)
    plt.bar([i for i in range(len(list_of_number_delays))],
            [j / sum(list_of_number_delays) for j in list_of_number_delays])
    plt.show()

    # CI calculation
    travel_times_list = []
    delay_times_list = []
    number_delays_list = []
    for i in range(run_size):
        system = run_simulation('Measure-1',
                                seed=None,
                                end_time=1600,
                                stats_step_size=50,
                                graph_type=graph_type,
                                tow_truck_mode=False,
                                warm_up=100)
        travel_times_list += system.final_statistics['route_travel_times']
        delay_times_list += system.final_statistics['route_delay_times']
        number_delays_list += system.final_statistics['route_number_delays']
    print('\n')
    print('Number of Route Travel Times - ', len(travel_times_list))
    mean_route_travel_time = sum(travel_times_list) / len(travel_times_list)
    std_route_travel_time = std(travel_times_list)
    print('Mean of Route Travel Time -', mean_route_travel_time)
    print('Standard Deviation of Route Travel Time -', std_route_travel_time)
    halfwidth_route_travel_time = ci(std_route_travel_time, run_size)
    print('Halfwidth of Route Travel Time -', halfwidth_route_travel_time)
    print('Range - ', mean_route_travel_time - halfwidth_route_travel_time,
          mean_route_travel_time + halfwidth_route_travel_time)
    # Also do CI calculation
    print('\n')
    print('Number of Delay Travel Times - ', len(delay_times_list))
    mean_delay_time = sum(delay_times_list) / len(delay_times_list)
    std_delay_time = std(delay_times_list)
    print('Mean of Delay Travel Time -', mean_delay_time)
    print('Standard Deviation of Delay Travel Time -', std_delay_time)
    halfwidth_delay_time = ci(std_delay_time, run_size)
    print('Halfwidth of Delay Travel Time -', halfwidth_delay_time)
    print('Range - ', mean_delay_time - halfwidth_delay_time,
          mean_delay_time + halfwidth_delay_time)
    print('\n')
    print('Number of Delays - ', len(number_delays_list))
    mean_delay_number = sum(number_delays_list) / len(number_delays_list)
    std_delay_number = std(number_delays_list)
    print('Mean of Delay Travel Time -', mean_delay_number)
    print('Standard Deviation of Delay Travel Time -', std_delay_number)
    halfwidth_delay_number = ci(std_delay_number, run_size)
    print('Halfwidth of Delay Travel Time -', halfwidth_delay_number)
    print('Range - ', mean_delay_number - halfwidth_delay_number,
          mean_delay_number + halfwidth_delay_number)
def perf_measure_3():

    # For incidents: distribution of the number of incidents in the whole network, at any
    # arbitrary epoch. This is similar to the previous question, but now for the fraction of time
    # that exactly k incidents are taking place simultaneously in the network

    graph_type = 'Highway'
    system = run_simulation('Measure-3-vis',
                            seed=40,
                            end_time=1600,
                            stats_step_size=50,
                            graph_type=graph_type,
                            tow_truck_mode=False,
                            warm_up=100)
    times_fraction_per_number_of_incidents = system.final_statistics[
        'time_spent_per_current_number_of_incidents']
    # rounded_times = [round(i) for i in times_fraction_per_number_of_incidents]
    # print(rounded_times)
    # counts_number_delays = Counter(number_delays_list)
    # list_of_number_delays = []
    # for i in range(max(number_delays_list) + 1):
    #     list_of_number_delays.append(counts_number_delays[i])
    print('Counts of time spent per number of incidents',
          times_fraction_per_number_of_incidents)
    print('len', len(times_fraction_per_number_of_incidents))
    min_non_zero_incidents = 0
    max_non_zero_incidents = len(times_fraction_per_number_of_incidents)
    i = 0
    while i < len(times_fraction_per_number_of_incidents
                  ) and times_fraction_per_number_of_incidents[i] == 0:
        min_non_zero_incidents += 1
        i += 1
    i = len(times_fraction_per_number_of_incidents) - 1
    while i > 0 and times_fraction_per_number_of_incidents[i] == 0:
        max_non_zero_incidents -= 1
        i -= 1
    print('max_non_zero_incidents', max_non_zero_incidents)
    print('min_non_zero_incidents', min_non_zero_incidents)

    plot = plt.figure()
    plt.xlabel('Numbers of incidents')
    plt.ylabel('Fraction of time spent')
    plt.xlim(min_non_zero_incidents - 1, max_non_zero_incidents)
    plt.bar([i for i in range(len(times_fraction_per_number_of_incidents))], [
        j / sum(times_fraction_per_number_of_incidents)
        for j in times_fraction_per_number_of_incidents
    ])
    plt.show()

    average_number_of_incidents = []
    # CI calculation
    for i in range(run_size):
        system = run_simulation('Measure-3' + str(i),
                                seed=i,
                                end_time=1600,
                                stats_step_size=50,
                                graph_type=graph_type,
                                tow_truck_mode=False,
                                warm_up=100)
        print('Run -', i)
        average_number_of_incidents.append(
            system.final_statistics['average_number_of_incidents'])

    mean_number_of_incidents = sum(average_number_of_incidents) / len(
        average_number_of_incidents)
    std_number_of_incidents = std(average_number_of_incidents)
    print('Mean of Number of Incidents -', mean_number_of_incidents)
    print('Standard Deviation of Number of Incidents -',
          std_number_of_incidents)
    halfwidth_number_of_incidents = ci(std_number_of_incidents, run_size)
    print('Halfwidth of Number of Incidents -', halfwidth_number_of_incidents)
    print('Range - ', mean_number_of_incidents - halfwidth_number_of_incidents,
          mean_number_of_incidents + halfwidth_number_of_incidents)
def perf_measure_2():

    # 2. For the network: distribution of the number of delayed vehicles at any arbitrary epoch.
    # Formulated differently, we would like to see a table where you simulate for k = 0; 1; 2; : : :
    # the fraction of time that exactly k vehicles are being delayed (consider it as being stuck
    # in a traffic jam).
    # Note that, in order to determine the second performance measure (number of
    # delayed vehicles in the network), it actually matters how many vehicles are driving in the
    # whole network. So now you need to add random vehicles in the network that drive between
    # the highway junctions. This part does not have to be implemented very realistically. You
    # may even assume that vehicles enter the network randomly at each of the nodes, travel one
    # link, and then leave the network again. For these vehicles, no origin-destination routing is
    # required. Only vehicles travelling from A to B have a fixed route. Our advice is to keep
    # it simple: do not introduce too many model parameters, like number of vehicles per hour
    # travelling on each link. You are allowed to assume that this rate is equal for all links.

    graph_type = 'Highway'
    system = run_simulation('Measure-2-vis',
                            seed=40,
                            end_time=1600,
                            stats_step_size=50,
                            graph_type=graph_type,
                            tow_truck_mode=False,
                            warm_up=100)
    times_delayed_per_number_of_cars = system.final_statistics[
        'time_spent_delayed_per_current_number_of_all_cars']
    # print('Time spent per number of delayed cars', times_delayed_per_number_of_cars)
    print('len', len(times_delayed_per_number_of_cars))

    data = [(i, times_delayed_per_number_of_cars[i])
            for i in range(len(times_delayed_per_number_of_cars))]
    x, y, bin_width = group_into_bins(data)
    print('x', x)
    print('y', y)
    print('len(y)', len(y))
    min_non_zero_delayed_cars = 0
    max_non_zero_delayed_cars = len(y) - 1
    # comparison = 0
    i = 0
    while i < len(y) and y[i] == 0:
        min_non_zero_delayed_cars += 1
        i += 1
        # i = x[i+1]
    i = len(y) - 1
    while i > 0 and y[i] == 0:
        max_non_zero_delayed_cars -= 1
        i -= 1
    print('max_non_zero_delayed_cars', max_non_zero_delayed_cars)
    print('min_non_zero_delayed_cars', min_non_zero_delayed_cars)

    plt.xlabel('Numbers of delayed cars (with Tow Trucks)')
    plt.ylabel('Fraction of time spent')
    plt.xlim(x[min_non_zero_delayed_cars] - 1, x[max_non_zero_delayed_cars])
    plt.bar(x, [j / sum(y) for j in y], width=bin_width * 0.8)
    plt.show()

    average_number_of_delayed_cars = []
    # CI calculation
    for i in range(run_size):
        system = run_simulation('Measure-2' + str(i),
                                seed=i,
                                end_time=1600,
                                stats_step_size=50,
                                graph_type=graph_type,
                                tow_truck_mode=False,
                                warm_up=100)
        print('Run -', i)
        average_number_of_delayed_cars.append(
            system.final_statistics['average_time_of_delay_of_all_cars'])

    mean_number_of_delayed_cars = sum(average_number_of_delayed_cars) / len(
        average_number_of_delayed_cars)
    std_number_of_delayed_cars = std(average_number_of_delayed_cars)
    print('Mean of Delayed Cars -', mean_number_of_delayed_cars)
    print('Standard Deviation of Delayed Cars -', std_number_of_delayed_cars)
    halfwidth_number_of_delayed_cars = ci(std_number_of_delayed_cars, run_size)
    print('Halfwidth of Delayed Cars -', halfwidth_number_of_delayed_cars)
    print('Range - ',
          mean_number_of_delayed_cars - halfwidth_number_of_delayed_cars,
          mean_number_of_delayed_cars + halfwidth_number_of_delayed_cars)