def initialize_populations(self): gen = self.network_factory.create_generator() dis = self.network_factory.create_discriminator() population_gen = Population(individuals=[Individual(genome=gen, fitness=gen.default_fitness)], default_fitness=gen.default_fitness) population_dis = Population(individuals=[Individual(genome=dis, fitness=dis.default_fitness)], default_fitness=dis.default_fitness) return population_gen, population_dis
def generate_samples(args, cc): print("generating samples") batch_size = 100 mixture_source = args.mixture_source output_dir = args.output_dir sample_size = args.sample_size dataloader = cc.create_instance(cc.settings['dataloader']['dataset_name']) network_factory = cc.create_instance(cc.settings['network']['name'], dataloader.n_input_neurons) population = Population(individuals=[], default_fitness=0) mixture_definition = read_settings( os.path.join(mixture_source, 'mixture.yml')) for source, weight in mixture_definition.items(): path = os.path.join(mixture_source, source) generator = network_factory.create_generator() generator.net.load_state_dict(torch.load(path)) generator.net.eval() population.individuals.append( Individual(genome=generator, fitness=0, source=source)) dataset = MixedGeneratorDataset( population, mixture_definition, sample_size * batch_size, cc.settings['trainer']['mixture_generator_samples_mode']) os.makedirs(output_dir, exist_ok=True) LipizzanerMaster().save_samples(dataset, output_dir, dataloader, sample_size, batch_size)
def calc_score(args, cc): score_calc = ScoreCalculatorFactory.create() cc.settings['general']['distribution']['client_id'] = 0 dataloader = cc.create_instance(cc.settings['dataloader']['dataset_name']) network_factory = cc.create_instance(cc.settings['network']['name'], dataloader.n_input_neurons) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') generator = network_factory.create_generator() generator.net.load_state_dict( torch.load(args.generator_file, map_location=device)) generator.net.eval() individual = Individual(genome=generator, fitness=0, source='local') dataset = MixedGeneratorDataset( Population(individuals=[individual], default_fitness=0), {'local': 1.0}, 50000, cc.settings['trainer']['mixture_generator_samples_mode']) output_dir = os.path.join(cc.output_dir, 'score') os.makedirs(output_dir, exist_ok=True) LipizzanerMaster().save_samples(dataset, output_dir, dataloader) inc = score_calc.calculate(dataset) _logger.info('Generator loaded from \'{}\' yielded a score of {}'.format( args.generator_file, inc))
def _create_population(all_parameters, create_genome, population_type): individuals = [ Individual.decode(create_genome, parameters['parameters'], source=parameters['source']) for parameters in all_parameters if parameters and len(parameters) > 0 ] return Population(individuals, float('-inf'), population_type)
def _parse_individual(json, create_genome): return Individual.decode(create_genome, json['parameters'], is_local=False, learning_rate=json['learning_rate'], optimizer_state=StateEncoder.decode( json['optimizer_state']), source=json['source'], id=json['id'])
def initialize_populations(self): populations = [None] * 2 populations[TYPE_GENERATOR] = Population( individuals=[], default_fitness=0, population_type=TYPE_GENERATOR) populations[TYPE_DISCRIMINATOR] = Population( individuals=[], default_fitness=0, population_type=TYPE_DISCRIMINATOR) for i in range(self._population_size): gen, dis = self.network_factory.create_both() populations[TYPE_GENERATOR].individuals.append( Individual(genome=gen, fitness=gen.default_fitness)) populations[TYPE_DISCRIMINATOR].individuals.append( Individual(genome=dis, fitness=dis.default_fitness)) populations[TYPE_GENERATOR].default_fitness = populations[ TYPE_GENERATOR].individuals[0].fitness populations[TYPE_DISCRIMINATOR].default_fitness = populations[ TYPE_DISCRIMINATOR].individuals[0].fitness return populations[TYPE_GENERATOR], populations[TYPE_DISCRIMINATOR]
def calc_inception_score(args, cc): inception_cal = InceptionCalculator(cuda=True) dataloader = cc.create_instance(cc.settings['dataloader']['dataset_name']) network_factory = cc.create_instance(cc.settings['network']['name'], dataloader.n_input_neurons) generator = network_factory.create_generator() generator.net.load_state_dict(torch.load(args.inception_file)) generator.net.eval() individual = Individual(genome=generator, fitness=0, source='local') dataset = MixedGeneratorDataset( Population(individuals=[individual], default_fitness=0), {'local': 1.0}, 50000) output_dir = os.path.join(cc.output_dir, 'inception_score') os.makedirs(output_dir, exist_ok=True) LipizzanerMaster().save_samples(dataset, output_dir, dataloader) inc = inception_cal.calculate(dataset) _logger.info( 'Generator loaded from \'{}\' yielded an inception score of {}'.format( args.inception_file, inc))
def evaluate_ensemble(self, individual, network_factory, mixture_generator_samples_mode='exact_proportion', fitness_type='tvd'): """It evaluates the solution/individual (ensemble) given the fitness type. It generates samples and it evaluates the metric defined by fitness_type using Lipizzaner. :parameter individual: Solutionto be evaluated :parameter network_factory: :parameter mixture_generator_samples_mode: :parameter fitness_type: It defines the type of metric to be evaluated. :return: The fitness_type metric value got by the solution. """ population = Population(individuals=[], default_fitness=0) # weight_and_generator_indices = [math.modf(gen) for gen in individual] # generators_paths, sources = self.ga.get_generators_for_ensemble(weight_and_generator_indices) # tentative_weights = [weight for weight, generator_index in weight_and_generator_indices] tentative_weights, generators_paths, sources = self.ga.get_mixture_from_individual( individual) mixture_definition = dict(zip(sources, tentative_weights)) for path, source in zip(generators_paths, sources): generator = network_factory.create_generator() generator.net.load_state_dict(torch.load(path, map_location='cpu')) generator.net.eval() population.individuals.append( Individual(genome=generator, fitness=0, source=source)) dataset = MixedGeneratorDataset(population, mixture_definition, 50000, mixture_generator_samples_mode) fid, tvd = self.score_calc.calculate(dataset) if fitness_type == 'tvd': return tvd, elif fitness_type == 'fid': return fid, elif fitness_type == 'tvd-fid': return (tvd, fid),
def create_ensemble(self): n_samples = 50000 using_max_size = self.ensemble_max_size != 0 population = Population(individuals=[], default_fitness=0) sources = [] current_tvd = 1.0 current_fid = 100 current_mixture_definition = dict() generators_examined = 0 self.show_experiment_configuration() start_time = time.time() while True: next_generator_path, source = self.get_next_generator_path() if next_generator_path == '': text = 'Warning: \n' text += 'No more generators to be examined to be added to the ensemble. \n' text += 'Generators examined: {}\n'.format(generators_examined) self.show_file_screen(text) if self.output_file != '': self.show_file_screen(text, self.output_file) break generator = self.network_factory.create_generator() generator.net.load_state_dict(torch.load(next_generator_path, map_location='cpu')) generator.net.eval() population.individuals.append(Individual(genome=generator, fitness=0, source=source)) sources.append(source) ensemble_size = len(population.individuals) tvd_tentative = 1.0 mixture_definition_i = dict() combinations_of_weights, size = self.get_weights_tentative(ensemble_size) if size == 0: break for tentative_mixture_definition in combinations_of_weights: mixture_definition = dict(zip(sources, tentative_mixture_definition)) dataset = MixedGeneratorDataset(population, mixture_definition, n_samples, self.mixture_generator_samples_mode) fid, tvd = self.score_calc.calculate(dataset) if tvd < tvd_tentative: tvd_tentative = tvd fid_tentative = fid mixture_definition_i = mixture_definition generators_examined += 1 text = 'Generators examined={} - Mixture: {} - FID={}, TVD={}, FIDi={}, TVDi={}, FIDbest={}, ' \ 'TVDbest={}'.format(generators_examined, mixture_definition, fid, tvd, fid_tentative, tvd_tentative, current_fid, current_tvd) self.show_file_screen(text) if self.output_file != '': self.show_file_screen(text+ '\n', self.output_file) if tvd_tentative < current_tvd: current_tvd = tvd_tentative current_fid = fid_tentative current_mixture_definition = mixture_definition_i convergence_time = 0 else: sources.pop() population.individuals.pop() convergence_time += 1 if using_max_size and len(sources) == self.ensemble_max_size: break else: if self.max_time_without_improvements!= 0 and convergence_time > self.max_time_without_improvements: break text = 'Finishing execution....\n' text += 'FID={}'.format(current_fid) text += 'TVD={}'.format(current_tvd) text += 'Generators examined={}'.format(generators_examined) text += 'Ensemble: {}'.format(current_mixture_definition) text += 'Execution time={} \n'.format(time.time() - start_time) self.show_file_screen(text) if self.output_file != '': self.show_file_screen(text, self.output_file) # dataset = 'mnist' # precision=10 # mode='random' # ensemble_max_size = 3 # greedy = GreedyEnsembleGenerator(dataset, ensemble_max_size, precision, generators_prefix='mnist-generator', generators_path='./mnist-generators/', # mode=mode) # # greedy.create_ensemble()