def try_with_params(**max_args): best_params, best_score, score_results = maximize(func, param_grid, args, verbose=True, **max_args) print("Score Results:\n{}".format(score_results)) self.assertEqual(best_params, {'x': 0., 'y': 0., 'z': True}) self.assertEqual(best_score, 2.)
def test_optimize(self): """ Simple hill climbing optimization with some twists. """ param_grid = { 'x': [-1., 0., 1.], 'y': [-1., 0., 1.], 'z': [True, False] } args = {'m': 1.} best_params, best_score, score_results, _, _ = maximize(func, param_grid, args, verbose=True) print("Score Results:\n{}".format(score_results)) self.assertEqual(best_params, {'x': 0., 'y': 0., 'z': True}) self.assertEqual(best_score, 2.)
def test_optimize(self): """ Simple hill climbing optimization with some twists. """ param_grid = { "x": [-1.0, 0.0, 1.0], "y": [-1.0, 0.0, 1.0], "z": [True, False] } args = {"m": 1.0} best_params, best_score, score_results, _, _ = maximize(func, param_grid, args, verbose=True) print("Score Results:\n{}".format(score_results)) self.assertEqual(best_params, {"x": 0.0, "y": 0.0, "z": True}) self.assertEqual(best_score, 2.0)
import numpy as np from evolutionary_search import maximize def func(x, y, m=1., z=False): return m * (np.exp(-(x**2 + y**2)) + float(z)) param_grid = {'x': [-1., 0., 1.], 'y': [-1., 0., 1.], 'z': [True, False]} args = {'m': 1.} best_params, best_score, score_results, _, _ = maximize(func, param_grid, args, verbose=False) print("best_params = %s" % best_params) print("best_score = %.2f" % best_score) print(score_results)
if distance >= max(y): os.system('scp distance.p distance_max.p') sys.stdout.flush() with open('out.txt','r') as f: generation_lines = [line for line in f.read().split("--- Evolve in 0 possible combinations ---")[-1].splitlines(False) if line] with open('generation_lines.txt','w') as f: f.write('\n'.join(generation_lines)) brushes.append(pg.mkBrush(color=colors[len(generation_lines)])) plot.setData(x=plot_dat[:,0],y=plot_dat[:,1],symbolBrush=brushes) pg.QtGui.QApplication.processEvents() #print("Max Distance = %f"%max(y)) #pickle.dump(distance,open('distance_realtime.p','wb')) #count += 1 return distance weights_permutations = {'w%d'%i:(np.linspace(-weights_scaling_factor,weights_scaling_factor,n_possible_weight_values) if rand_init else (np.random.rand(n_possible_weight_values)-0.5)*weights_scaling_factor) for i in range(n_weights)} # (np.random.rand(100)-0.5)*0.5 bias_permutations = {'b%d'%i:(np.linspace(-bias_scaling_factor ,bias_scaling_factor,n_possible_weight_values) if rand_init else (np.random.rand(n_possible_weight_values)-0.5 )*bias_scaling_factor) for i in range(n_bias)} #weights_permutations = {'w%d'%i:(np.linspace(-weights_scaling_factor,weights_scaling_factor,n_possible_weight_values) + (weights_scaling_factor if activation == 'relu' else 0.) if rand_init else (np.random.rand(n_possible_weight_values)-0.5 + (0.5 if activation == 'relu' else 0.))*weights_scaling_factor) for i in range(n_weights)} # (np.random.rand(100)-0.5)*0.5 #bias_permutations = {'b%d'%i:(np.linspace(-bias_scaling_factor ,bias_scaling_factor,n_possible_weight_values) + (bias_scaling_factor if activation == 'relu' else 0.) if rand_init else (np.random.rand(n_possible_weight_values)-0.5 + (0.5 if activation == 'relu' else 0.))*bias_scaling_factor) for i in range(n_bias)} weights_permutations.update(bias_permutations) best_params, best_score, score_results, hist, log = maximize(distance,weights_permutations,{}, population_size=population_size, generations_number=generations_number, gene_mutation_prob=gene_mutation_prob, gene_crossover_prob = gene_mutation_prob, tournament_size=tournament_size, verbose=True) pickle.dump((best_params, best_score, score_results, hist, log),open('final_model.p','wb')) best_weights = {best_params[weight] for weight in weights_permutations} pickle.dump((best_weights,architecture,activation),open('weights.p','wb'), protocol=2) ## FIXME send best weights/model to weights.p when done # FIXME do some ML on the evolution of the hyperparameters # PCA plot of weights with showing evaluation results colored # individual vs score, real time pickle.dump((np.array(X),np.array(y)), open('X_y.p','wb')) # plot these later on
alpha=1e-5, hidden_layer_sizes=(2), random_state=1) from evolutionary_search import EvolutionaryAlgorithmSearchCV cv = EvolutionaryAlgorithmSearchCV(estimator=SVC(), params=paramgrid, scoring="accuracy", cv=StratifiedKFold(n_splits=4), verbose=1, population_size=50, gene_mutation_prob=0.10, gene_crossover_prob=0.5, tournament_size=3, generations_number=5, n_jobs=1) cv.fit(X, y) from evolutionary_search import maximize def func(x, y, m=1., z=False): return m * (np.exp(-(x**2 + y**2)) + float(z)) param_grid = {'x': [-1., 0., 1.], 'y': [-1., 0., 1.], 'z': [True, False]} args = {'m': 1.} best_params, best_score, score_results, hist, logbook = maximize(func, param_grid, args, verbose=False) print(best_params) print(best_score) print(score_results) #TODO: test this program with Neural Network Model
def scan(self, model, X, y, aim='worst'): """Scan a Keras model. Args: model (keras model): Keras model to be scanned X (numpy nd-array): Input Data for scanning y (numpy array): Input Labels for scanning aim (str, optional): If 'worst' is chosen, SAFE learns to generate adversarial samples. If 'better' is chosen, SAFE learns to improve accuracy. Defaults to 'worst'. """ if not isinstance(X, np.ndarray): X = X.values if not isinstance(y, np.ndarray): y = y.values [rows, self.n_features] = X.shape if self.n_points is not None: X, _, y, _ = train_test_split(X, y, train_size=self.n_points / rows, random_state=self.random_state, stratify=y) self.X = X self.y_better = np.zeros((rows, self.n_features)) self.y_worst = np.zeros((rows, self.n_features)) self._generate_combination() self.model = model self.aim = aim # TODO migrate this also if self.combinations_mode == 'genetic': param_grid = {'combination': self.combinations} for i, j in enumerate(tqdm(X)): args = {'data': j, 'label': y_train.values[i]} best_params, _, _, _, _ = maximize( self.__combination_search_genetic, param_grid, args, verbose=False) self.X_train_fs[i, :] = j self.y_train_fs[i, :] = best_params['combination'] elif self.combinations_mode == 'forward_selection': if self.aim == 'better': for i, j in enumerate(tqdm(self.X)): self.y_better[ i, :] = self.__combination_search_forward_selection_min( j, y[i]) else: for i, j in enumerate(tqdm(self.X)): self.y_worst[ i, :] = self.__combination_search_forward_selection_max( j, y[i]) else: losses = np.zeros((rows, self.combinations.shape[0])) for index, p in enumerate(tqdm(self.combinations)): losses[:, index] = abs( self.model.predict(np.multiply(p, self.X)).flatten() - y) self.y_worst = self.combinations[losses.argmax(axis=1)] self.y_better = self.combinations[losses.argmin(axis=1)]
def meta_data(X, y, dataset_id, algorithms, cat_ind, preprocessors, path, metadata): ''' Runs the pipeline on dataset X, returns the score and logs the pipeline. Parameters: ----------- X: pd.DataFrame Contains the dataframe of a given dataset excluding its target column. y: pd.Series Contains the series of the target of a given dataset. dataset_id: integer Contains the id of the dataset to be optimized. algorithms: list Contains the search space of predictive algorithms. cat_ind: list Contains boolean values to determine whether a column is categorical or not based on OpenML implementation. preprocessors: list Contains the searchspace of preprocessing algorithms. path: string Contains the path to the directory in where the files are logged. metadata: pd.DataFrame Contains the dataframe of the metadata for dataset with id X. Returns: -------- str Contains confirmation that the optimization has been ran for dataset with dataset_id. ''' categorical, numeric, string = category_numeric_or_string(X, cat_ind) X, y = impute(X, y, categorical, numeric, string, 'mean') if len(preprocessors) > 0: param_grid = { 'p1': preprocessors, 'p2': preprocessors, 'p3': preprocessors, 'alg': algorithms, 'k': [1, 2, 5, 10, 25] } args = { 'X': X, 'y': y, 'cat_ind': cat_ind, 'dataset_id': dataset_id, 'categorical': categorical, 'numeric': numeric, 'string': string, 'path': path, 'metadata': metadata } best_params, best_score, score_results, _, _ = maximize( pipeline_run, param_grid, args, verbose=False, generations_number=10, population_size=100, tournament_size=6, n_jobs=1, gene_mutation_prob=0.50, gene_crossover_prob=0.90) else: for algorithm in algorithms: for k in [1, 2, 5, 10, 25]: pipeline_run(X, y, dataset_id, algorithm, cat_ind, k, categorical, numeric, string, path, metadata, p1=None, p2=None, p3=None) return "Dataset {} has finished running.".format(dataset_id)