def test_stat(_type=Stat.MAType.Simple): stat = Stat.SMAStat( "Test stats") if _type == Stat.MAType.Simple else Stat.EMAStat() for i in range(1, 100): stat.update(i) stat.print()
def linscale(_list): if len(_list) == 0: return _list import cortex.statistics as Stat stat = Stat.SMAStat() for elem in _list: stat.update(elem) # Scale between 0 and the absolute maximum scaled = [stat.abs_max * (x - stat.min) / (stat.max - stat.min) for x in _list] #print(scaled) return scaled
def calibrate(self): if len(self.nets) == 0: return import cortex.network as cn import cortex.functions as Func # Reset the champion self.champion = None net_stats = Stat.SMAStat() top_fitness = -math.inf # Compute the absolute fitness of the species for net_id in self.nets: absolute_fitness = cn.Net.Ecosystem[net_id].fitness.absolute if (self.champion is None or absolute_fitness > top_fitness): self.champion = net_id top_fitness = absolute_fitness net_stats.update(absolute_fitness) print( f'>>> Champion for species {self.ID}: {self.champion} (fitness: {cn.Net.Ecosystem[self.champion].fitness.absolute})' ) # Compute the relative fitness of the networks # belonging to this species for net_id in self.nets: # Compute the relative fitness net = cn.Net.Ecosystem[net_id] net.fitness.relative = net_stats.get_offset(net.fitness.absolute) # print("Network", net_id, "fitness:", # "\t\tAbsolute:", cn.Net.Ecosystem[net_id].fitness.absolute, # "\t\tRelative:", cn.Net.Ecosystem[net_id].fitness.relative) self.fitness.set(net_stats.mean)
def calibrate(_run, _epoch): if get_rank() != 0: return print("\n======[ Calibrating ecosystem ]======\n") # Remove extinct species. extinct = [species.ID for species in cs.Species.Populations.values() if len(species.nets) == 0] while len(extinct) > 0: del cs.Species.Populations[extinct.pop()] # Reset the global champion. cn.Net.Champion = None # Running statistics about species fitness species_stat = Stat.SMAStat() # Highest fitness seen so far. top_fitness = -math.inf params = {} complexity_stat = Stat.SMAStat() for net in cn.Net.Ecosystem.values(): params[net.ID] = net.get_parameter_count() complexity_stat.update(params[net.ID]) for net_id in params.keys(): # This means that for identical absolute fitness, an individual with # lower complexity would have a higher relative fitness. cn.Net.Ecosystem[net_id].complexity = complexity_stat.get_inv_offset(params[net_id]) for species in cs.Species.Populations.values(): # Compute the relative network fitness # and the absolute species fitness. species.calibrate() species_stat.update(species.fitness.absolute) if (cn.Net.Champion is None or cn.Net.Ecosystem[species.champion].fitness.absolute > top_fitness): cn.Net.Champion = species.champion top_fitness = cn.Net.Ecosystem[species.champion].fitness.absolute for species in cs.Species.Populations.values(): # Compute the relative species fitness species.fitness.relative = species_stat.get_offset(species.fitness.absolute) print(f'>>> Global champion: {cn.Net.Champion} (fitness: {cn.Net.Ecosystem[cn.Net.Champion].fitness.absolute})') # Save the champion if cn.Net.Champion is not None: save_net(cn.Net.Ecosystem[cn.Net.Champion], f'/run_{_run}/epoch_{_epoch}', 'Champion') # Store statistics Conf.Stats['Species_count'].update(len(cs.Species.Populations)) Conf.Stats['Network_count'].update(len(cn.Net.Ecosystem)) Conf.Stats['Champion_parameter_count'].update(cn.Net.Ecosystem[cn.Net.Champion].get_parameter_count()) Conf.Stats['Highest_fitness'].update(cn.Net.Ecosystem[cn.Net.Champion].fitness.absolute) epoch_stats = { 'Average_fitness': Stat.SMAStat(), 'Average_initial_fitness': Stat.SMAStat(), 'Champion_parameter_count': Stat.SMAStat() } if not Conf.UnitTestMode: for net in cn.Net.Ecosystem.values(): if net.ID == cn.Net.Champion: epoch_stats['Champion_parameter_count'].update(net.get_parameter_count()) epoch_stats['Average_fitness'].update(net.fitness.absolute) if net.age == 0: epoch_stats['Average_initial_fitness'].update(net.fitness.absolute) # Global statistics for key, stat in Conf.Stats.items(): Conf.Logger.add_scalar(key, stat.current_value, _epoch) # Epoch statistics for key, stat in epoch_stats.items(): Conf.Logger.add_scalar(key, stat.mean, _epoch) stat.title = key save_stat(stat, f'/run_{_run}/epoch_{_epoch}')
def init(): if get_rank() != 0: return """ Initialise the ecosystem and generate initial species if speciation is enabled. """ print("\n======[ Initialising ecosystem ]======\n") # Reset the static network attributes cn.Net.reset() # Reset the static species attributes cs.Species.reset() # Reset all statistics for key, val in Conf.Stats.items(): Conf.Stats[key] = Stat.SMAStat() # Sanity check on the species count if cs.Species.Enabled: assert cs.Species.Init.Count > 0, "Invalid initial species count %r" % cs.Species.Init.Count assert cs.Species.Init.Count <= cn.Net.Init.Count, "Initial species count (%r) is greater than the initial network count (%r)" % (cs.Species.Init.Count, cn.Net.Init.Count) else: cs.Species.Init.Count = 1 cs.Species.Max.Count = 1 # Population size (the number of networks per species). net_quota = cn.Net.Init.Count // cs.Species.Init.Count # Initial proto-net. # This is the first self-replicating prion to spring # into existence in the digital primordial bouillon. proto_net = cn.Net(_isolated = True) probabilities = { 'layer': 1, 'node': 1, 'stride': 1, 'kernel': 1 } if cs.Species.Enabled: # Generate proto-species and proto-nets while True: # Generate proto-species. proto_species = cs.Species(_genome = proto_net.get_genome()) # Generate proto-nets for this proto-species. for n in range(net_quota): proto_net = cn.Net(_species = proto_species) if len(cs.Species.Populations) == cs.Species.Init.Count: break proto_net = cn.Net(_species = proto_species, _isolated = True) while cs.Species.find(proto_net.get_genome()) != 0: proto_net.mutate(_probabilities = probabilities, _structure = True, _parameters = True) else: # Generate proto-species. proto_species = cs.Species(_genome = proto_net.get_genome()) # Generate proto-nets. for n in range(net_quota): proto_net = cn.Net(_species = proto_species) proto_net.mutate(_probabilities = probabilities, _structure = True, _parameters = True) print(f'Network count: {len(cn.Net.Ecosystem)}') for net in cn.Net.Ecosystem.values(): print(net.as_str()) print(f'Species count: {len(cs.Species.Populations)}') for species in cs.Species.Populations.values(): print(species.as_str())
class Conf: ExperimentName = 'Experiment' Runs = 1 Epochs = 50 Episodes = 5 DiscountFactor = 0.99 Epsilon = 1.0e-8 Device = torch.device('cpu') UseCuda = False GPUCount = 0 MaxWorkers = 1 DataDir = '' DownloadData = False DataLoadArgs = {} DataLoader = None TrainBatchSize = 128 TestBatchSize = 1000 TrainPortion = None LogDir = './logs' LogInterval = 500 Logger = None OutputFunction = tnf.log_softmax OutputFunctionArgs = {'dim': 1} LossFunction = tnf.nll_loss Optimiser = torch.optim.Adadelta OptimiserArgs = { 'lr': 1.0 } UnitTestMode = False Evaluator = None GPUs = [] Workers = [] Tag = Tags.Start Stats = { 'Species_count': Stat.SMAStat(), 'Network_count': Stat.SMAStat(), 'Champion_parameter_count': Stat.SMAStat(), 'Highest_fitness': Stat.SMAStat() } def __init__(self, _run, _epoch, _gpu_slot = None): self.run = _run self.epoch = _epoch self.episodes = Conf.Episodes self.gpu_slot = None self.train_batch_size = Conf.TrainBatchSize self.test_batch_size = Conf.TestBatchSize self.train_portion = Conf.TrainPortion self.data_dir = Conf.DataDir self.data_load_args = Conf.DataLoadArgs self.download_data = Conf.DownloadData self.device = Conf.Device self.log_interval = Conf.LogInterval self.loss_function = Conf.LossFunction self.optimiser = Conf.Optimiser self.optimiser_args = Conf.OptimiserArgs self.output_function = Conf.OutputFunction self.output_function_args = Conf.OutputFunctionArgs self.evaluator = Conf.Evaluator self.data_loader = Conf.DataLoader self.discount_factor = Conf.DiscountFactor self.epsilon = Conf.Epsilon