def _statloop(self):
   while not self.shutdown:
     with self.statwakeup:
       if self.settings.statinterval <= 0: self.statwakeup.wait()
       else:
         now = time.time()
         stats = Statistics(obj = self.core, ghashes = self.core.stats.ghashes, starttime = self.core.stats.starttime)
         stats.avgmhps =  1000. * stats.ghashes / (now - stats.starttime)
         stats.children = self.core.get_worker_statistics() \
                        + self.core.get_work_source_statistics() \
                        + self.core.get_blockchain_statistics()
         with self.lock:
           self._insert_stats(now, stats)
           self.db.commit()
         self.statwakeup.wait(self.settings.statinterval)
Ejemplo n.º 2
0
from core.statistics import Statistics

log = logging.getLogger("Main")

if __name__ == '__main__':

    parser = argparse.ArgumentParser(description='Ragpicker Statistics')
    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       help='additional help')

    parser_long = subparsers.add_parser('long',
                                        help="Show statistics (long version)")
    parser_long.set_defaults(which='long')
    parser_short = subparsers.add_parser(
        'short', help="Show statistics (short version)")
    parser_short.set_defaults(which='short')
    parser_av = subparsers.add_parser('av',
                                      help="Show statistics (AV version)")
    parser_av.set_defaults(which='av')

    args = vars(parser.parse_args())

    logo()

    if args['which'] == 'long':
        Statistics().runStatisticsLong()
    elif args['which'] == 'short':
        Statistics().runStatisticsShort()
    elif args['which'] == 'av':
        Statistics().runStatisticsAV()
Ejemplo n.º 3
0
from core.config import config
from core.environments import XORProblem
from core.statistics import Statistics
from core import neat, interface

env = XORProblem()
stats = Statistics()
algorithm = neat.NEAT(env.evaluate)
network_visualizer = interface.NetworkVisualizer()

for run in range(config.num_runs):
    for i in range(config.num_iter):
        best_individual = algorithm.epoch(stats)

        if config.visualize_best_networks:
            for spec in algorithm.population.species:
                for individual in spec.individuals:
                    network_visualizer.update_node_positions(
                        individual.connections, individual.nodes)

        if env.solved:
            stats.update_run(env.evaluations, best_individual)
            break

    if config.visualize_best_networks:
        network_visualizer.visualize_network(best_individual.connections)

    interface.plot_overall_fitness(stats.best_fitnesses, stats.avg_fitnesses,
                                   stats.stdev_fitnesses)
    interface.plot_structures(stats.avg_num_hidden_nodes,
                              stats.stdev_num_hidden_nodes,