def get_population_size(learned, cmaes): if cmaes: l = CMAES(lambda x: None, learned, verbose=False) return l.batchSize else: l = SNES(lambda x: None, learned, verbose=False) return l.batchSize
def markovSourceDenoise(transition_prob, deletion_rate, weighted=False): global delta delta = transition_prob global rho rho = deletion_rate global max_del max_del = 2 global n n = 10000 display = 50 global alphabet alphabet = ['+', '-'] global orig orig = generateSequence(n, delta) global noisy noisy = deletionChannel(orig, rho) est1 = denoiseSequence2(noisy, k, alphabet, rho, max_del) #est2 = denoiseSequence3(noisy, k, alphabet, rho) est4 = denoiseSequence4(noisy, k, alphabet, rho) est = optimalDenoise(noisy, k, alphabet, rho, delta) print 'Setting: delta = ', delta, ', rho = ', rho print 'Original: ', orig[:display], '(length ', len( orig), ' error ', error(orig, orig) / (n + 0.0), levenshtein( orig, orig) / (n + 0.0), ')' print 'Noisy: ', noisy[:display], '(length ', len(noisy), ' error ', error( noisy, orig) / (n + 0.0), levenshtein(noisy, orig) / (n + 0.0), ')' print 'Optimal Denoised: ', est[:display], '(length ', len( est), ' error ', error(est, orig) / (n + 0.0), levenshtein( est, orig) / (n + 0.0), ' )' print 'Denoiser 1: ', est1[:display], '(length ', len( est1), ' error ', error(est1, orig) / (n + 0.0), levenshtein( est1, orig) / (n + 0.0), ')' print 'Denoiser 4: ', est4[:display], '(length ', len( est4), ' error ', error(est4, orig) / (n + 0.0), levenshtein( est4, orig) / (n + 0.0), ')' #print 'Denoiser 2: ', est2[:display], '(length ', len(est2), ' error ', error(est2, orig)/(n+0.0), ')' if weighted: l1 = CMAES(weightWrapper1, [1]) l1.minimize = True l1.maxEvaluations = 200 opt_vals1 = l1.learn() weights1 = opt_vals1[0] err1 = opt_vals1[1] #l2 = CMAES(weightWrapper2, [1]*k) #l2.minimize = True #l2.maxEvaluations = 200 #opt_vals2 = l2.learn() #weights2 = opt_vals2[0] #err2 = opt_vals2[1] print(weights1) weighted_est1 = denoiseSequence2(noisy, k, alphabet, rho, max_del, weights1) #weighted_est2 = denoiseSequence3(noisy, k, alphabet, rho, k, weights2) print 'Weighted Denoiser 1: ', weighted_est1[:display], '(length ', len( weighted_est1), ' error ', err1, ')' #print 'Weighted Denoiser 2: ', weighted_est2[:display], '(length ', len(weighted_est2), ' error ', err2, ')' print '\n' * 5
def trainOne(index): def opt_func(w): return (np.sum((np.dot(x_train, w) - y_train2[:, index]) ** 2) - 1000 * np.sum(np.sign(w) - 1)) l = CMAES(opt_func, np.random.randn(np.shape(x_train)[1])) l.minimize = True opt_w = l.learn()[0] return opt_w
def trainNetwork(data, n_classes, buildNet, file, seed, max_evaluations, num_samples): # The training functions uses the average of the cumulated reward and maximum height as fitness X_train = data["X_train"] y_train = data["y_train"] def objF(params): nn = buildNet(X_train.shape[1], n_classes) nn._setParameters(np.array(params)) random_state = np.random.get_state() np.random.seed(l.numLearningSteps) sampled_data = np.random.choice(len(X_train), num_samples, replace=False) np.random.set_state(random_state) cur_data = X_train[sampled_data] cur_label = y_train[sampled_data] cum_correct = 0 for example, cor in zip(cur_data, cur_label): result = nn.activate(example) loss_sum = 0 for q, out in enumerate(result): if q != cor: loss_sum += max(0, out - result[int(cor)] + 1) # guess = np.argmax(result) #if guess == cor: #cum_correct += 1 cum_correct += loss_sum nn.reset() return cum_correct # Build net for initial random params n = buildNet(X_train.shape[1], n_classes) learned = n.params testNetwork(data, n_classes, learned, buildNet, 0, file, seed) l = CMAES(objF, learned, verbose=False) batch_size = l.batchSize # l._setBatchSize = batch_size l.maxEvaluations = max_evaluations l.minimize = True for i in xrange((max_evaluations/batch_size)): result = l.learn(additionalLearningSteps=1) learned = result[0] testNetwork(data, n_classes, learned, buildNet, num_samples * (i + 1) * batch_size, file, seed) return learned
def optimize_pose(self, marker_id, save_transform=True): """ Find optimized transform for marker relative to master tag :param marker_id: id for marker :param save_transform: bool, update optimized marker pose dict or not :return optimized pose """ x0 = np.zeros(7) self.optimize_id = marker_id l = CMAES(self.objF, x0) l.minimize = True l.maxEvaluations = 1000 pose = l.learn() print marker_id, pose # DEBUG if save_transform: self.optimized_marker_poses[marker_id] = pose[0] return pose[0]
def train_network(X_train, y_train, X_validate, y_validate, X_test, y_test, test_split=0, validate_split=0): file_start = "%d\t%d\t%d" % (seed, test_split, validate_split) n = buildNet(X_train.shape[1], n_classes) learned = n.params population_size = get_population_size(learned, cmaes) evaluations_per_generation = population_size * batch_size num_generations = max_evaluations / (evaluations_per_generation) + 1 # Used to sample a batch with same class ratios from sklearn.cross_validation import StratifiedShuffleSplit sss = StratifiedShuffleSplit(y_train.reshape(-1), num_generations, train_size=batch_size, random_state=seed) train_indices = [batch_index for (batch_index, _) in sss] def objF(params): nn = buildNet(X_train.shape[1], n_classes) nn._setParameters(np.array(params)) cur_data = X_train[train_indices[l.numLearningSteps]] cur_label = y_train[train_indices[l.numLearningSteps]] results = [] for example, cor in zip(cur_data, cur_label): results.append(nn.activate(example)) nn.reset() loss = log_loss(cur_label, results) return loss test_network(X_validate, y_validate, learned, 0, file_start, "val") test_network(X_test, y_test, learned, 0, file_start, "test") l = SNES(objF, learned, verbose=False) if cmaes: l = CMAES(objF, learned, verbose=False) l.minimize = True l.maxEvaluations = num_generations * population_size for generation in xrange(num_generations): result = l.learn(additionalLearningSteps=1) learned = result[0] train_evaluations = (generation + 1) * evaluations_per_generation test_network(X_train[train_indices[generation]], y_train[train_indices[generation]], learned, train_evaluations, file_start, "train") test_network(X_validate, y_validate, learned, train_evaluations, file_start, "val") test_network(X_test, y_test, learned, train_evaluations, file_start, "test") if generation % 100 == 0: f.flush()
for i in range(num_experiments): # set up environment, task, neural net, agent, and experiment env = InfoMaxEnv(object_names, action_names, num_objects, False) task = InfoMaxTask(env, max_steps=max_steps) net = buildNetwork(task.outdim, task.indim, bias=True, outclass=SoftmaxLayer) if algorithm == 'pgpe': agent = OptimizationAgent( net, PGPE(storeAllEvaluations=True, minimize=False, verbose=False)) elif algorithm == 'cmaes': agent = OptimizationAgent(net, CMAES(minimize=False, verbose=False)) experiment = EpisodicExperiment(task, agent) exp_desciptions.append([i, agent, experiment, task]) pool = Pool(processes=num_cpus) res = [] if algorithm == 'pgpe': res = pool.map(run_experiment, exp_desciptions) elif algorithm == 'cmaes': for desc in exp_desciptions: res.append(run_experiment(desc)) else: for desc in exp_desciptions:
def CMAES_Factory(): return CMAES()
from pybrain.rl.agents import OptimizationAgent from pybrain.optimization import CMAES from pybrain.rl.experiments import EpisodicExperiment batch = 2 #number of samples per learning step prnts = 100 #number of learning steps after results are printed epis = int(4000 / batch / prnts) #number of roleouts numbExp = 10 #number of experiments et = ExTools(batch, prnts) #tool for printing and plotting for runs in range(numbExp): # create environment env = CartPoleEnvironment() # create task task = BalanceTask(env, 200, desiredValue=None) # create controller network net = buildNetwork(4, 1, bias=False) # create agent with controller and learner (and its options) agent = OptimizationAgent(net, CMAES(storeAllEvaluations=True)) et.agent = agent # create the experiment experiment = EpisodicExperiment(task, agent) #Do the experiment for updates in range(epis): for i in range(prnts): experiment.doEpisodes(batch) et.printResults((agent.learner._allEvaluations)[-50:-1], runs, updates) et.addExps() et.showExps()
reader = csv.reader(f) for row in reader: ds.addSample(convert(row[0]),convert(row[1])) #testds, trainds = ds.splitWithProportion(0.2) net = buildNetwork(20, 20, 20) #trainer = BackpropTrainer(net, dataset=trainds, learningrate=learning_rate) trainer = BackpropTrainer(net, dataset=ds, learningrate=learning_rate) #trainer.train() #trainer.trainEpochs(5) trainer.trainUntilConvergence() score = 0 for x, y in testds: predict = unconvert(net.activate(x)) score += damerau_levenshtein_distance(predict,unconvert(y)) global lastNet lastNet = net global netNum netNum += 1 print "Network " + str(netNum) + " done with score " + str(score) return score x0 = [0.01] optimizer = CMAES(makeNet, x0, minimize=True, maxLearningSteps=10) print optimizer.learn()