def fitness_from_points(points): '''Takes some points, builds a map and returns the fitness value ''' mymap, _ = create_map(mp.feature_resolution, mp.domain) mymap, _ = niche_compete(points, mymap, mp.domain) fitness = np.nansum(mymap.fitness.flatten()) return (fitness)
def dotrue(file,n): points = getdata(file)[:n] mp.map = create_map(mp.feature_resolution, mp.domain) for point in points: mp.map.updatemap( [point] ) print(np.nansum(mp.map.fitness.flatten())) return(np.nansum(mp.map.fitness.flatten()))
def pred_true_map(pred_map): truemap,_ = create_map( mp.feature_resolution , mp.domain ) rows = np.linspace(0,len(pred_map[0])-1,len(pred_map[0])) cols = np.linspace(0,len(pred_map)-1,len(pred_map)) indexes = list(it.product(rows, cols)) for i in indexes: j = tuple([int(a) for a in i]) truemap.fitness[j] = mp.fitness_fun(pred_map[j]) truemap.genomes[j] = pred_map[j] return(truemap)
def evalgenomes(genomes): truemap, _ = create_map(mp.feature_resolution, mp.domain) rows = np.linspace(0, 24, 25) cols = np.linspace(0, 24, 25) indexes = list(it.product(rows, cols)) for count, g in enumerate(genomes): j = tuple([int(a) for a in indexes[count]]) truemap.fitness[j] = mp.fitness_fun(g) truemap.genomes[j] = g return (truemap)
def pred_true_map(pred_map): '''Takes a prediction map as input and outputs a map with those points and their true fitness values ''' truemap = create_map(mp.feature_resolution, mp.domain) rows = np.linspace(0, len(pred_map[0]) - 1, len(pred_map[0])) cols = np.linspace(0, len(pred_map) - 1, len(pred_map)) indexes = list(it.product(rows, cols)) for i in indexes: j = tuple([int(a) for a in i]) truemap.fitness[j] = mp.fitness_fun(list(pred_map[j])) truemap.genomes[j] = pred_map[j] return (truemap)
def create_prediction_map( model, observed, UCB=False, means=True, bop=False, *args, ): '''create_prediction_map creates a prediction map by using the map made from all the current best points and then using map-elites to illuminate it using the current acquisition function. Example: prediction_map = create_prediction_map( gp , points) Input: model - [ GPy model ] - the current posterior GP observed - [ n*[ [ x ],[ y ],[ f ] ] ] - all evaluated points *args - extra args Output: prediction_map - [ Map Class ] - The best map with current data. Code Author: Paul Kent Warwick University email: [email protected] Oct 2020; Last revision: 14-Oct-2020 ''' #Make acquisition acq_fun = build_pytorch_acq_fun(model, UCBflag=UCB, meansflag=means) #seed map with precise evaluations prediction_map = create_map(mp.feature_resolution, mp.domain) prediction_map.initialisemap(observed) if bop: prediction_map.initialisemeans(observed) prediction_map.estimatemeans() #prediction_map.generate_niche_models(model) prediction_map.calcstdmeans(observed, model.mean_module.constant.item()) acq_fun = build_bop_pred_acq_fun(model, prediction_map, UCBflag=UCB, meansflag=means) prediction_map = map_elites(mp.domain, init_map=prediction_map, feat_fun=mp.feature_fun, fit_fun=acq_fun, plot=False, me_params=mp.PM_params) return (prediction_map)
def create_prediction_map( model, observed, UCB=False, means=True, *args, ): '''create_prediction_map creates a prediction map by using the map made from all the current best points and then using map-elites to illuminate it using the current acquisition function. Example: prediction_map = create_prediction_map( gp , points) Input: model - [ GPy model ] - the current posterior GP observed - [ n*[ [ x ],[ y ],[ f ] ] ] - all evaluated points *args - extra args Output: prediction_map - [ Map Class ] - The best map with current data. Code Author: Paul Kent Warwick University email: [email protected] Oct 2020; Last revision: 14-Oct-2020 ''' fdims = len(mp.feature_resolution) mins = mp.domain.feat_mins maxs = mp.domain.feat_maxs xdims = len(mp.example) #Make acquisition acq_fun = build_pytorch_acq_fun(model, UCBflag=UCB, meansflag=means) #seed map with precise evaluations prediction_map, _ = create_map(mp.feature_resolution, mp.domain) prediction_map, _ = niche_compete(points=observed, map=prediction_map, domain=mp.domain) prediction_map = map_elites(mp.domain, init_map=prediction_map, feat_fun=mp.feature_fun, fit_fun=acq_fun, plot=False, me_params=mp.PM_params) return (prediction_map)
def evaluate_points(points): truemap , _ = create_map( mp.feature_resolution , mp.domain ) truemap , _ = niche_compete(points,truemap,mp.domain) fitness = np.nansum(truemap.fitness.flatten()) print(fitness) return(truemap , fitness)
# sobolmap,fitness = getpredmap(initial_samples) # sobol_fit_list.append(fitness) # pickle.dump(sobol_fit_list, filehandler) #### ### Random Samples def random_point(n, dims): x=[] for i in range(n): x.append(np.random.uniform(0,1,dims)) return(x) random_fit_list = [] for i in range(1): ss.initseed(i) x = random_point(10,10) rand_points = [[x[i],mp.fitness_fun(x[i]),mp.feature_fun(x[i])] for i in range(len(x))] for i in range(len(rand_points)): rand_points[i][1] = np.nansum(rand_points[i][1]) filehandler = open('Results/Init-Test/Random/fitness.csv', 'wb') mp.map , edges = create_map(mp.feature_resolution, mp.domain ) initialisemap(rand_points) randommap,fitness = getpredmap(rand_points) random_fit_list.append(fitness) pickle.dump(sobol_fit_list, filehandler)
def map_elites(domain, init_map=None, fit_fun=mp.domain.fit_fun, feat_fun=mp.domain.feat_fun, experiment=False, number_evals=mp.n_gens, plot=False, verbose=False): num_cores = multiprocessing.cpu_count() pool = multiprocessing.Pool(num_cores) def sample(n, sample_map=None, init=False, fitness_fun=mp.domain.fit_fun, feature_fun=mp.domain.feat_fun, plot=True, sample_pool=pool): '''Sample performs the calls to the objective and feature functions and returns them in the correct format for Map-Elites ''' if sample_map == None: sample_map = mp.map population = np.array( create_children(batchsize=10**4, map=sample_map, initialise=init, plot=plot)) fitness = np.array(parallel_eval(fitness_fun, population, sample_pool)) #print(fitness) behaviour = [] # for pop in population: # behaviour.append(eval( 'feature_fun' )( pop )) behaviour = np.array( parallel_eval(feature_fun, population, sample_pool)) # behaviour = np.array( behaviour ) sampled_points = [[population[i], fitness[i], behaviour[i]] for i in range(n)] return (sampled_points) ####################################################################### ################# Initialising ######################################## ####################################################################### if init_map == None: experiment = True if mp.map is None: mp.map, edges = create_map(mp.feature_resolution, mp.example) mymap = init_map init_n = mp.n_children # init_n : initial population size sampled_points = sample(n=init_n, sample_map=mymap, init=True, fitness_fun=fit_fun, plot=plot, sample_pool=pool) mymap, improvement_percentage = niche_compete(sampled_points, mymap) ####################################################################### ################### Map-Elites ####################################### ####################################################################### generation = 1 terminate = False popsize = mp.n_children while terminate != True: if experiment: mymap = None new_samples = sample(n=popsize, sample_map=mymap, fitness_fun=fit_fun, plot=plot) sampled_points.extend(new_samples) mymap, improvement_percentage = niche_compete(points=new_samples, map=mymap) if verbose: print('generation ', generation, ' accepted ', improvement_percentage, ' % of points') generation += 1 if generation > number_evals: terminate = True sampled = [s[0] for s in sampled_points] # x1 = [x[0] for x in sampled] # x2 = [x[1] for x in sampled] # plt.scatter(x1,x2) # plt.show() if experiment: return () return (mymap)
def bop_elites(max_evals=me, unknown_features=False, preload=None, n_initial_samples=20): '''bop_elites (THIS IS V0.9 RUNNING ON MULTIDIMENSIONAL DETERMINISTIC FEATURES ) bop-elites performs Bayesian Optimisation of Phenotypic Elites by means of the ensemble expected improvement algorithm. On domains where the features are deterministic and calculable this simplifies to the classic expected improvement algorithm. Example: output_predictions = bop_elites( max_evals = 500 ) Inputs (arguments): max_evals - [ Integer ] - Evaluation budget unknown_features - [ Boolean ] - Flag to activate Ensemble EI preload - [ Array ] - Preloaded evaluations n_initial_samples - [ Integer ] - Number of samples to initialise Inputs (from config file): mp.domain - [ Domain Class ] - Domain specific information mp.map - [ Map Class ] - Global map (for map-elites) mp - [ Script ] - Contains many variables Outputs map - [ Map Class ] - Final optimised map objvallist - [ List ] - Objective values of points in map Code Author: Paul Kent Warwick University email: [email protected] Oct 2020; Last revision: 20-01-2021 ''' ss.myseed = seed ss.initseed(ss.myseed) print('starting experiment with seed: ', seed, ' niche_size: ', niche_size) ## Initialise main map mp.feature_resolution = [niche_size, niche_size] mp.map = create_map(mp.feature_resolution, mp.domain, GMLM=GMLM) ## Set up for Data-Collection DC_training_times = [] DC_niches_filled = [] ## Create a Readme file and the directory for storage mydir, logger = readme(domain_flag, n_initial_samples, max_evals, seed, mp.penalty, info, optn) printinfo('intro', max_evals, n_initial_samples, domain_flag, seed, logger=logger) ## pretty print to terminal ## Set the Fitness and feature functions from config file ofun = mp.fitness_fun ffun = mp.feature_fun #### Initial sampling if preload == None: observations = initial_sampling(n_initial_samples) printinfo(type='sampling', logger=logger) else: directory = preload #Must be the parent directory pointfile = open(directory + 'points.b', 'rb') data = pickle.load(pointfile) observations = data nanfile = open(directory + 'nanpoints.b', 'rb') nandata = pickle.load(nanfile) mp.map.nanmap = nandata print(str(len(observations)) + ' samples loaded') n_initial_samples = len(observations) ## Set counters n_samples = n_initial_samples itercount = 1 mp.map.initialisemap(observations) # Fit initial samples into map mp.map.initialisemeans(observations) mp.map.estimatemeans() mp.nancounter = 0 mp.observations = observations #mp.map.updatemeans(observations[-1]) DC_niches_filled.append(count_niches_filled()) #Keep track of niches ## Build GP for fitness printinfo('train_gp', n_samples, logger=logger) retrain = True #Initial value to train new GP hyperparameters omodel, training_time, hypers = buildpymodel2(observations, n_initial_samples) tic = time.time() #mp.map.generate_niche_models(omodel) print('models generated in ', time.time() - tic) DC_training_times.append(training_time) #Keep track of training times mp.map.calcstdmeans(observations, omodel.mean_module.constant.item()) # Update means if unknown_features: #TODO - reimplement unknown features # # obs_f = np.reshape( [ feat for feat in mp.map. flatten() ],[ -1 , xdims ] ) # # fmodel = buildmodel(obs_x,obs_fy) pass # Calculate initial solution value objvallist = [] objval = calc_objval() objvallist.append(objval) printinfo('initscore', objval, logger=logger) printinfo('line', logger=logger) ## Main Acquisition Loop for i in range(max_evals - n_initial_samples): printinfo('acquisition', itercount, n_samples, logger=logger) ## Perform BOP-Elites nextpoint, _, candidatelist = DoContinuousBOPELITES( omodel, optn, acq='BOP') #This performs the actual BOP-Elites triallist = np.copy(candidatelist) valuefound = False while len(triallist) > 0: nextpoint = triallist[-1] #print(nextpoint) newobs = new_sample(ofun, ffun, nextpoint) if newobs[-1] == False: triallist = [] observations.append(newobs[:-1]) valuefound = True else: #obslist.append(newobs[:-1]) print(mp.nancounter) mp.saved_points = np.delete(mp.saved_points, -1) triallist = triallist[:-1] if not valuefound: print(observations[0][0]) print(candidatelist[-1]) mp.map.store_nan(candidatelist[-1]) savenans(mp.map.nanmap, mydir) newobs = expand_nan(ofun, ffun, candidatelist[-1]) observations.append(newobs[:-1]) printinfo('nans', mp.nancounter, logger=logger) printinfo('new point', newobs[0], observations, logger=logger) ## Update GP printinfo('train_gp', itercount, logger=logger) if valuefound: omodel, training_time, hypers = buildpymodel2( observations, n_initial_samples) fantasies = mp.map.fantasize_nans() # else: # observations_plus = observations #, training_time , hypers = buildpymodel2( observations_plus , # n_initial_samples)#, #*hypers , #retrain = retrain) retrain = not retrain #Toggle flag ie- Don't retrain Hyper-parameters every iteration ## Update the main map of solutions. mp.map.updatemap(observations) mp.map.updatepointmean([observations[-1]]) mp.map.updatemeans(observations[-1], omodel, mp.feature_resolution) #mp.map.generate_niche_models(omodel) if len(fantasies) > 0: #obsplus = np.vstack([observations , fantasies]) #print(obsplus[:-3]) observations_plus = np.vstack([observations, np.array(fantasies)]) omodel = update_with_nans(observations_plus, omodel) #omodel , training_time , hypers = buildpymodel2( obsplus, n_initial_samples) #mp.map.generate_niche_models(omodel) mp.map.calcstdmeans(observations, omodel.mean_module.constant.item()) # Update means #Data_Collection nniches = count_niches_filled() DC_niches_filled.append(nniches) DC_training_times.append(training_time) objval = calc_objval() objvallist.append(objval) printinfo('current_value', objval, logger=logger) printinfo('line', logger=logger) savepoints(observations, mydir) #Save current observations itercount += 1 n_samples += 1 printinfo('final_value', str(np.nansum(mp.map.fitness)), logger=logger) print(f'\n Illuminating Final Prediction Map') pred_map, pred_map_value = getpredmap(omodel, observations, logger) save_data(DC_training_times, DC_niches_filled, objvallist, pred_map_value, mp.map.fitness, pred_map.genomes, seed, observations, mydir) return (mp.map, objvallist)
from sail_lib import * from create_prediction_map import create_prediction_map from mapelites.mapelites import map_elites from mapelites.createmap import create_map seed = mp.seed np.random.seed(seed) # Initialisation parameters max_evals = 30 preload = None n_initial_samples = 20 initial_samples = initial_sampling(n_initial_samples) mp.map, edges = create_map(mp.feature_resolution, mp.example) initialisemap(initial_samples) ########## mp.n_children = 10 solution_value = 0 def calculate_final_score(mymap): '''This function takes the predictive map and calculates the predicted score by assessing their value on the real functions. ''' xdims = len(mp.domain.valid_ranges) genomes = mymap.genomes[~np.isnan(mymap.fitness)].flatten() truevals = [mp.fitness_fun(x) for x in np.reshape(genomes, [-1, xdims])]
def bop_elites(max_evals=500, unknown_features=False, preload=None, n_initial_samples=40): '''bop_elites (THIS IS V0.9 RUNNING ON MULTIDIMENSIONAL DETERMINISTIC FEATURES ) bop-elites performs Bayesian Optimisation of Phenotypic Elites by means of the ensemble expected improvement algorithm. On domains where the features are deterministic and calculable this simplifies to the classic expected improvement algorithm. Example: output_predictions = bop_elites( max_evals = 500 ) Inputs (arguments): max_evals - [ Integer ] - Evaluation budget unknown_features - [ Boolean ] - Flag to activate Ensemble EI preload - [ Array ] - Preloaded evaluations n_initial_samples - [ Integer ] - Number of samples to initialise Inputs (from config file): mp.domain - [ Domain Class ] - Domain specific information mp.map - [ Map Class ] - Global map (for map-elites) mp - [ Script ] - Contains many variables Outputs map - [ Map Class ] - Final optimised map objvallist - [ List ] - Objective values of points in map Code Author: Paul Kent Warwick University email: [email protected] Oct 2020; Last revision: 20-01-2021 ''' ## Initialise main map mp.map = create_map(mp.feature_resolution, mp.domain) ## Set up for Data-Collection DC_training_times = [] DC_niches_filled = [] ## Create a Readme file and the directory for storage mydir, logger = readme(domain_flag, n_initial_samples, max_evals, seed, mp.penalty, info) printinfo('intro', max_evals, n_initial_samples, domain_flag, seed, logger=logger) ## pretty print to terminal ## Set the Fitness and feature functions from config file ofun = mp.fitness_fun ffun = mp.feature_fun ## Set counters n_samples = n_initial_samples itercount = 1 ### Initial sampling if preload == None: observations = initial_sampling(n_initial_samples) printinfo(type='sampling', logger=logger) else: directory = preload filehandler = open(directory, 'rb') data = pickle.load(filehandler) observations = data print(str(len(observations)) + ' samples loaded') n_initial_samples = len(observations) # mp.map.initialisemap(observations ) # Fit initial samples into map # mp.map.initialisemeans(observations) # mp.map.estimatemeans() # mp.map.updatemeans() # DC_niches_filled.append(count_niches_filled() ) #Keep track of niches # ## Build GP for fitness # printinfo('train_gp' , n_samples, logger = logger) # retrain = True #Initial value to train new GP hyperparameters # omodel , training_time , hypers = buildpymodel2( observations , n_initial_samples ) # tic = time.time() # mp.map.generate_niche_models(omodel) # print( 'models generated in ', time.time()-tic) # DC_training_times.append( training_time ) #Keep track of training times # if unknown_features: # #TODO - reimplement unknown features # # # obs_f = np.reshape( [ feat for feat in mp.map. flatten() ],[ -1 , xdims ] ) # # # fmodel = buildmodel(obs_x,obs_fy) # pass # # Calculate initial solution value # objvallist = [] ; objval = calc_objval() ; objvallist.append( objval ) # printinfo( 'initscore' , objval , logger = logger) ; printinfo( 'line', logger = logger ) # ## Main Acquisition Loop # for i in range(max_evals-n_initial_samples): # printinfo( 'acquisition' , itercount , n_samples , logger = logger ) # ## Perform BOP-Elites # nextpoint, _ = DoContinuousBOPELITES(omodel, 20) #This performs the actual BOP-Elites nextpoint = [ 0.35589097848392837, 0.12011312106715394, 0.07221528184130153, 0.6026451701847786, 0.7502119783418484, 9.356622763723033e-07, 0.41690933761766574, 0.18620351698501855, 0.947183335541234, 0.6021678002258849 ] observations.append(new_sample(ofun, ffun, nextpoint)) printinfo('new point', nextpoint, observations, logger=logger) # ## Update GP # printinfo('train_gp' , itercount, logger = logger) # omodel , training_time , hypers = buildpymodel2( observations , # n_initial_samples)#, # #*hypers , # #retrain = retrain) # retrain = not retrain #Toggle flag ie- Don't retrain Hyper-parameters every iteration # ## Update the main map of solutions. # mp.map.updatemap( observations ) # mp.map.updatepointmean([observations[-1]]) # mp.map.estimatemeans() # mp.map.updatemeans( ) # mp.map.generate_niche_models(omodel) # #Data_Collection # DC_niches_filled.append( count_niches_filled( ) ) # DC_training_times.append( training_time ) # objval = calc_objval() # objvallist.append( objval ) # printinfo('current_value' , objval , logger = logger) ; printinfo( 'line', logger = logger) # savepoints(observations , mydir ) #Save current observations # itercount += 1 ; n_samples += 1 # printinfo('final_value' , str( np.nansum( mp.map.fitness ) ), logger = logger ) # print(f'\n Illuminating Final Prediction Map') # pred_map, pred_map_value = getpredmap(omodel, observations) # save_data( DC_training_times, # DC_niches_filled, # objvallist , # pred_map_value , # mp.map.fitness , # pred_map.genomes , # seed, # observations, # mydir ) return (mp.map)