def test(self): """ Test that every image is correctly recognized. """ Experiment.test(self) start = time.time() num_confused = 0.0 classifier = self.network.get_classifier() i = 0 while self.image_iterator.has_next(): image, category, img_idx = self.image_iterator.next() recognized = self.network.do_inference(numpy.array(image), category) if not recognized: active_cats = classifier.get_winning_category() #print colored("Failed: " + category + " recognized as "+active_cats, 'red') num_confused += 1 i += 1 if i % self.PRINT_INCR == 0: print "Iter:", i confusion_rate = num_confused / float(i) elapsed = (time.time() - start) print "Testing time:", elapsed print "Time per category:", (elapsed / i) print colored("Testing complete", "green") print colored("\nConfusion rate: " + str(confusion_rate), 'cyan')
def run_experiment(args): """ Parallelizable method for computing experiments. This method is used in parallel computation for running experiments in parallel. Due to the nature of pickling, it must be declared globally, because instance methods cannot be pickled. """ # args is a tuple, so that we can map over an array of tuples. # see run_parallel_experiments() params, param_name, val = args params = params.copy() params[param_name] = val while True: try: start_time = time.clock() exp = Experiment(**params) exp.compute_informativeness() break except Exception: traceback.print_exc() elapsed_time = time.clock() - start_time print "Experiment with val %s added in %0.2f seconds" % \ (str(val), elapsed_time) return val, exp
def altruism(self, altruisticProbability, selfishProbability, altruismCost, altruismBenefit, disease, harshness, numTicks): """ Runs an experiment of the Biology/Evolution/Altruism model. :returns: The table output of the experiment. """ job = uuid4() exp_path = '/tmp/%s/experiment.xml' % job out_path = '/tmp/%s/out.csv' % job params = { 'altruistic-probability': altruisticProbability, 'selfish-probability': selfishProbability, 'cost-of-altruism': altruismCost, 'benefit-from-altruism': altruismBenefit, 'disease': disease, 'harshness': harshness, } exp = Experiment(steps=numTicks, params=params) exp.add_metric(color='pink').add_metric(color='green') exp.write_xml(exp_path) model = '%s/models/Sample Models/Biology/Evolution/Altruism.nlogo' % NETLOGO_HOME self.call_experiment(model, exp_path, exp.name, out_path) with open(out_path, 'r') as out_file: return out_file.read()
def __init__(self): Experiment.__init__(self) persistance.Dommable.__init__(self) self.amplifiers = {'None':'bridge', 'Prana':'Prana', 'Milmega 1':'Milmega', 'Milmega 2':'Milmega'} self.amplifier = EnumerateProperty('None',['Automatic'] + self.amplifiers.keys()) self.amplifier.changedTo.connect(self.setAmplifier)
def testQValueNetwork(startTurn=0, loopNum=1000, type=''): agents = [] win_nums = {} test_name = PLAYER_LIST[type][0] test_filename = TEST[type] if os.path.isfile(test_filename): with open(test_filename, 'r') as f: win_nums = pickle.load(f) for i in range(0, 3): playerName = PLAYER_LIST[type][i] nw = NETWORK[type](playerName) if playerName == test_name: nw.loadNet(playerName, startTurn) rfa = AGENT[type](playerName, nw) agents.append(rfa) env = RunFastEnvironment() exp = Experiment(env, agents) for i in range(loopNum): if not win_nums.get(startTurn): win_nums[startTurn] = {} testHistory = exp.doTest(test_name) for j in range(0,3): playerName = PLAYER_LIST[type][j] if not win_nums[startTurn].get(playerName): win_nums[startTurn][playerName] = {'point': 0, 'win': 0} win_nums[startTurn][playerName]['point'] += testHistory[playerName] if testHistory['name'] == playerName: win_nums[startTurn][playerName]['win'] += 1 with open(test_filename, 'w') as f: pickle.dump(win_nums, f)
def individualStrategies(): #allxVals = {1: range(4, 10, 5), 2: range(100, 111, 10)} allxVals = {1: range(4, 101, 5), 2: range(100, 1001, 10)} allPlayerTypes = {'Random Play': players.RandomPlayer, 'Honest Play': players.HonestPlayer, 'Minimum Guessing': players.MinimumGuessingPlayer, 'Constant Guessing': players.ConstantGuessPlayer, 'Mean Guessing': players.MeanGuessPlayer, 'Quantile Guessing': players.QuantileGuessPlayer, } allExperimentTypes = [2] allStatistics = [2] for statistic in allStatistics: for experimentType in allExperimentTypes: xVals = allxVals[experimentType] for title, playerType in allPlayerTypes.items(): playerTypes = {playerType: 1.0} savefile = title.replace(' ', '_')+str(experimentType)+str(statistic)+'.png' print "Running "+savefile exp = Experiment(xVals, playerTypes, experimentType, statistic) yVals = exp.run() print yVals plotResults(exp, yVals, title, savefile) print
def train(self): """ Store a copy of every image in the iterator. """ Experiment.train(self) start = time.time() gabor = GaborRegion((144, 192), rotations=3, initial_wavelength=3, num_wavelengths=2) # Regions = [ GaborRegion, AndRegion, OrRegion (classifier) ] self.network = AndOrNetwork((144,192), num_regions=1, input_region = gabor) and_region = self.network.regions[1] classifier = self.network.get_classifier() i = 0 while self.image_iterator.has_next(): image, category, img_idx = self.image_iterator.next() gabor.do_inference(numpy.array(image)) active_nodes = gabor.get_active_nodes() pos = and_region.create_node((0,0), cxns = active_nodes) classifier.create_node(category, pos) i += 1 if i % self.PRINT_INCR == 0: print "Iter:", i and_region.prepare_for_inference() classifier.prepare_for_inference() num_cxns = and_region.get_num_cxns() + classifier.get_num_cxns() print "Number of connections:", num_cxns elapsed = (time.time() - start) print "Training time:", elapsed print "Time per category:", (elapsed / i) print colored("Training complete", "green")
def train(self): """ Store a copy of every image in the iterator. """ Experiment.train(self) start = time.time() self.image_shape = (144, 192) gabor = GaborRegion(self.image_shape, rotations=3, initial_wavelength=3, num_wavelengths=2) # Regions = [ GaborRegion, AndRegion, OrRegion (classifier) ] self.network = AndOrNetwork((144,192), num_regions=2, input_region = gabor) f1 = self.network.regions[1] f2 = self.network.regions[2] classifier = self.network.get_classifier() self.gabor_acts = gabor.precompute_image_activations(self.image_iter) windows = self.get_windows() for window in windows: self.network.prepare_for_inference(1) elapsed = (time.time() - start) total_cxns = 0 for i, r in enumerate(self.network.regions[1:]): num_cxns = r.get_num_cxns() print "Region %s cxns: %s" % (i, num_cxns) total_cxns += num_cxns print "Total connections:", total_cxns print "Training time:", elapsed print "Time per category:", (elapsed / i) print colored("Training complete", "green") def test(self): """ Test that every image is correctly recognized. """ Experiment.test(self) start = time.time() classifier = self.network.get_classifier() i = 0 while self.image_iterator.has_next(): image, category = self.image_iterator.next() recognized = self.network.do_inference(numpy.array(image), category) if not recognized: active_cats = classifier.get_active_categories() print colored("Failed: " + category + " recognized as "+repr(active_cats), 'red') i += 1 if i % self.PRINT_INCR == 0: print "Iter:", i elapsed = (time.time() - start) print "Testing time:", elapsed print "Time per category:", (elapsed / i) print colored("Testing complete", "green")
def load_code_from_file(self, filename): experiment = Experiment() experiment.load_code_from_file(filename) self.project.experiments.append(experiment) self.project.active_experiment = experiment self.update_functions_UI(self.project.active_experiment.exec_model.statements) self.update_functions_context(self.project.active_experiment, self.project.active_experiment.exec_model.statements)
def __init__(self, output_path=None, linewidth=1.5): e = Experiment(output_path) self.linewidth = linewidth if output_path is None: self.output_path = os.path.join(e.final_output_path, self.default_plots_path_addon) else: self.output_path = output_path e.makedir(self.output_path)
def __init__(self): Experiment.__init__(self) self.passCriterion = ExperimentSlot(parent=self,defaultValue='VoltageCriterion') self.transmittedPower = ExperimentSlot(parent=self,defaultValue='TransmittedPower') self.powerMinimum = Property(Power(-30.,'dBm'),changedSignal=self.settingsChanged) self.powerMaximum = Property(Power(+15.,'dBm'),changedSignal=self.settingsChanged) self.frequencies = SweepRange(Frequency(150e3),Frequency(1500e6),21,changedSignal=self.settingsChanged)
def main(): try: folder_name = sys.argv[1] experiment = Experiment(folder_name) except IndexError: experiment = Experiment() experiment.retrieve_data() parser = FeatureParser() parser.initialize_matrix(experiment.raw_data_set) parser.print_global_names()
def quantileStrategy(): xVals = [10] playerTypes = {players.QuantileGuessPlayer: 1.0} experimentType = 2 statistic = 1 title = "Quantile Guessing" exp = Experiment(xVals, playerTypes, experimentType, statistic) yVals = exp.run() print yVals
def run_model(): experiment = Experiment(model = "../experiments/model-guthrie.json", task = "../experiments/task-guthrie.json", result = "data/test-experiment-guthrie.npy", report = "data/test-experiment-guthrie.txt", n_session = 8, n_block = 1, seed = 1, rootdir=os.path.dirname(__file__)) # for unittest and nosetests. records = experiment.run(session, save=True, force=True, parse=False) records = np.squeeze(records) mean = np.mean(records["best"], axis=0)[-1] assert mean >= 0.85
def main(): data = Experiment() data.retrieve_data() emails = [] for example in data.raw_data_set: emails.append(Email(example[1])) i = 1 with open("dates.csv", "w") as dates_file: for email in emails: dates_file.write(str(i) + ","+str(email.get_hour()) + "\n")
def runExperiment(self): try: e = Experiment(int(self.sampleEntry.get()), int(self.populationEntry.get()), int(self.numSuccessesEntry.get())) e.perform(int(self.numTrialsEntry.get())) self.drawResult(e.results, 0) except AssertionError as error: tkMessageBox.showerror('Data Entry Error', error.args[0]) except ValueError as error: tkMessageBox.showerror('Data Entry Error', 'Please make sure each field is filled out' + ' and only contains numbers')
def main(): if len(sys.argv) < 2: sys.stderr.write("Need to pass user folder name\n") return folder_name = sys.argv[1] experiment = Experiment(folder_name) experiment.retrieve_data() parser = FeatureParser(experiment.raw_data_set) (names, secondary_names, body_text) = parser.get_mail_elements("data/beck-s/moscoso__mike/4.") print names print secondary_names print body_text
def __init__(self): Experiment.__init__(self) # Load cluster information self.loadClusters() self.makeSeedUsersData() self.makeFriendListData() self.makeLikeVectorData() self.makeTweetListLikedByEgoNetworkMembers() self.makeLikeCountData() self.makeMentionCountData() self.makeMutualFriendsCountData() self.makeClusterData()
def __init__(self): Experiment.__init__(self) self.transmittedPower = ExperimentSlot(parent=self,defaultValue='TransmittedPower') self.measurement = ExperimentSlot(parent=self,defaultValue='ReceivedPower') #,defaultValue='VoltageCriterion') self.generatorPower = Property(Power(+10,'dBm'),changedSignal=self.settingsChanged) self.generatorFrequency = ScalarProperty(Frequency(1,'GHz'),changedSignal=self.settingsChanged,minimum=Frequency(1,'Hz')) self.startPosition = ScalarProperty(Position(22,'mm'),changedSignal=self.settingsChanged) self.stopPosition = ScalarProperty(Position(-24,'mm'),changedSignal=self.settingsChanged) self.xPosition = ScalarProperty(Position(122,'mm'),changedSignal=self.settingsChanged) self.zPosition = ScalarProperty(Position(84,'mm'),changedSignal=self.settingsChanged) self.numberOfSteps = ScalarProperty(Integer(11),minimum=Integer(1),maximum=Integer(10001),changedSignal=self.settingsChanged)
def run(agent_count, duration): for s in STRATEGIES: test = None if 'mixed' in s: test = Experiment(agent_count, s, duration, mixed_strategies=(s.split(' ')[1], s.split(' ')[2])) elif 'random-tsp' in s: test = Experiment(agent_count, s, duration, s.split(' ')[1]) else: test = Experiment(agent_count, s, duration) test.start_game() average_idle_results[s].append(test.average_idle) max_idle_results[s].append(test.max_idle) exploration_time_results[s].append(test.exploration_time) alerts_detected_results[s].append(test.normalized_alerts)
def load(self, dirname): """ Loads the project from the given directory. The existing state of the project is completely modified. """ # TODO: We should formalize this dependency at some point and move # this import to the top level from configobj import ConfigObj if dirname == "": raise IOError("Cannot load project from empty path.") elif not os.path.isdir(dirname): raise IOError("Cannot find directory: " + dirname) filename = abspath(join(dirname, self.PROJECT_FILE_NAME)) if not os.path.isfile(filename): raise IOError('Cannot load %s from project directory "%s".' % \ (self.PROJECT_FILE_NAME, dirname)) # Every project is saved as a text ConfigObj file that describes # the name and location of the real data files. configspec = ConfigObj(self.CONFIG_SPEC, list_values=False) config = ConfigObj(filename, configspec=configspec) contexts = [] for context_config in config["Contexts"].values(): ctx = DataContext.load(join(dirname, context_config["file"])) ctx.name = context_config["name"] contexts.append(ctx) self.contexts = contexts experiments = [] if hasattr(scripting, "app"): app = scripting.app else: app = None for exp_config in config["Experiments"].values(): experiment = Experiment() exp_dir = join(dirname, exp_config["save_dir"]) experiment.load_from_config(exp_config, exp_dir, project=self) experiments.append(experiment) self.experiments = experiments proj_config = config["Project"] if proj_config.has_key("active_experiment"): self.active_experiment = self.find_experiment(proj_config["active_experiment"]) # Update Project Save Path self.project_save_path = dirname return
def test_experiment(source_data): # the oracles p_ = [0.55, 0.56, 0.57, 0.58, 0.59, 0.60, 0.75, 0.80, 0.85, 0.90] oracles_ = [NoisyOracle(pi) for pi in p_] ie_oracles_ = [IENoisyOracle(pi) for pi in p_] wt_oracles_ = [WTNoisyOracle(pi) for pi in p_] # the parameters for the experimentation train_p = 0.7 n_rounds = 200 eps = 0.9 alpha = 0.05 # number of repetitions n_rep = 10 # the final accuracies for Random, Repeated, and IEThresh acc_rnd = [0 for i in range(n_rounds)] acc_rep = [0 for i in range(n_rounds)] acc_iet = [0 for i in range(n_rounds)] acc_wei = [0 for i in range(n_rounds)] accuracy_ = [acc_rnd, acc_rep, acc_iet, acc_wei] # the data set data_set = source_data.get_dataset() # for each method for k in range(len(method)): ora_ = oracles_ # the oracles if k == 2: ora_ = ie_oracles_ elif k == 3: ora_ = wt_oracles_ # repeat the experiment n_rep times and take the average for the accuracy for i in range(n_rep): experiment_ = Experiment(data_set, train_p, ora_, n_rounds, eps, alpha) this_accuracy_ = experiment_.run_exp(method[k]) # update the overall accuracy with this experiment for j in range(n_rounds): accuracy_[k][j] += this_accuracy_[j] print('k=' + str(k) + ', round: ' + str(i)) # averaging for k in range(len(method)): for i in range(n_rounds): accuracy_[k][i] /= n_rep source_data.record_accuracy(acc_rnd, acc_rep, acc_iet, acc_wei) # plot fig = plt.gcf() fig.set_size_inches(10, 10) for i in range(len(accuracy_)): plt.plot(accuracy_[i], label=method[i]) plt.legend(bbox_to_anchor=(1, 0.225)) plt.show()
def train(self): """ Store a copy of every image in the iterator. """ Experiment.train(self) start = time.time() num_images = len(self.image_iterator) print "Num images:", num_images assert num_images > 0 gabor = self.gabor_region = GaborRegion((144, 192), rotations=3, initial_wavelength=3, num_wavelengths=2) kmeans = KmeansRegion(max(1,int(float(num_images) * self.compression)), self.window_sampler) and_region = AndOrRegion(kmeans.image_shape, num_images) # Regions = [ GaborRegion, Kmeans, AndRegion, OrRegion (classifier) ] self.network = AndOrNetwork([gabor, kmeans, and_region]) classifier = self.network.get_classifier() self.categories = [] print "Extracting windows..." i = 0 while self.image_iterator.has_next(): image, category, img_idx = self.image_iterator.next() self.categories.append(category) gabor.do_inference(numpy.array(image)) kmeans.do_learning() i += 1 print "Training K-means..." kmeans.prepare_for_inference() # Send all of the images through the feature learner to save the image # activations. print "Storing classifier features..." self.image_iterator.reset() while self.image_iterator.has_next(): image, category, img_idx = self.image_iterator.next() gabor.do_inference(numpy.array(image)) kmeans.do_inference() cxns = kmeans.get_active_nodes() pos = and_region.create_node((0,0), cxns = cxns) classifier.create_node(category, pos) print "Preparing for inference..." self.network.prepare_for_inference(2)
def trainQValueNetwork(loopNum=10000, startTurn=0, history_filename='train_winners_nn', inputNum=192, type=1): ''' 通过让三个agent互相玩游戏,然后来训练出一个Q值网络 三个agent的网络保存在playeri里面,数字分别代表的是训练了多少次后得出的网络 胜负情况记录在train_winners里面 ''' agents = [] winners = {} if os.path.isfile(history_filename): with open(history_filename, 'r') as f: winners = pickle.load(f) startTurn = sum([v for i,v in winners.items()]) for i in range(0, 3): playerName = PLAYER_LIST[i] nw = RunFastNetwork(playerName, inputNum=inputNum, hiddenNum=inputNum, outNum=1) nw.loadNet(playerName, startTurn) rfa = RunFastAgent(playerName, nw) agents.append(rfa) env = RunFastEnvironment() exp = Experiment(env, agents, type=type) for i in xrange(startTurn, startTurn + loopNum): if i % 200 == 0: for agent in agents: agent.saveNet() with open(history_filename, 'w') as f: pickle.dump(winners, f) # exp.setTurn(i) winner = exp.doEpisode() if winners.has_key(winner): winners[winner] += 1 else: winners[winner] = 1 for agent in agents: agent.saveNet() with open(history_filename, 'w') as f: pickle.dump(winners, f) print winners with open(history_filename, 'w') as f: pickle.dump(winners, f)
def trainDeepNetwork(loopNum=10000, startTurn=0, history_filename='train_winners_dn', type=1, inputNum=192): ''' 用深度网络来训练Q值 ''' agents = [] winners = {} # load history match if os.path.isfile(history_filename): with open(history_filename, 'r') as f: winners = pickle.load(f) startTurn = sum([v for i,v in winners.items()]) # load agents with network for i in range(0, 3): playerName = PLAYER_LIST[i] nw = RunFastDeepNetwork(playerName, inputNum=inputNum, hidden1Num=inputNum, hidden2Num=inputNum, hidden3Num=inputNum, outNum=1) nw.loadNet(playerName, startTurn) rfa = RunFastAgent(playerName, nw) agents.append(rfa) env = RunFastEnvironment() exp = Experiment(env, agents, type=type) for i in range(startTurn, startTurn + loopNum): if i % 200 == 0: for agent in agents: agent.saveNet() with open(history_filename, 'w') as f: pickle.dump(winners, f) # exp.setTurn(i) winner = exp.doEpisode() if winners.has_key(winner): winners[winner] += 1 else: winners[winner] = 1 for agent in agents: agent.saveNet() with open(history_filename, 'w') as f: pickle.dump(winners, f) print winners with open(history_filename, 'w') as f: pickle.dump(winners, f)
def enter(self): # get the starting time from the parent self.state_time = self.get_parent_state_time() self.start_time = self.state_time # save the starting state time #self.log['start_time'] = self.start_time # add the callback to the schedule delay = self.state_time - now() if delay < 0: delay = 0 if self.interval < 0: # schedule it for every frame schedule_delayed(self.callback, delay) else: # schedule the interval (0 means once) schedule_delayed_interval(self.callback, delay, self.interval) # say we're active self.active = True # update the parent time if necessary if self.duration > 0: self.advance_parent_state_time(self.duration) # if we don't have the exp reference, get it now if self.exp is None: from experiment import Experiment self.exp = Experiment.last_instance() # custom enter code self._enter() pass
def test_model(): experiment = Experiment(model = "../experiments/model-guthrie.json", task = "../experiments/task-guthrie.json", result = "data/test-experiment-guthrie.npy", report = "data/test-experiment-guthrie.txt", n_session = 25, n_block = 1, seed = 1, rootdir=os.path.dirname(__file__)) records = experiment.run(session, save=False, force=True, parse=False) records = np.squeeze(records) mean = np.mean(records["best"], axis=0)[-1] std = np.std(records["best"], axis=0)[-1] print("Mean performance: %.2f ± %.2f" % (mean, std)) print("-"*30) assert mean >= 0.85
def _ParallelWithPrevious(name=None, parallel_name=None, blocking=True): # get the exp reference from experiment import Experiment try: exp = Experiment._last_instance() except AttributeError: raise StateConstructionError( "You must first instantiate an Experiment.") # find the parent parent = exp._parents[-1] # find the previous child state (-1 because this is not a state) try: prev_state = parent._children[-1] parallel_parent = parent except IndexError: prev_state = parent if parent._parent is None: parallel_parent = parent._exp else: parallel_parent = parent._parent # build the new Parallel state with Parallel(name=parallel_name, parent=parallel_parent, blocking=blocking) as p: p.override_instantiation_context(3) p.claim_child(prev_state) with Serial(name=name) as s: s.override_instantiation_context(3) yield p
def enter(self): # get the starting time from the parent self.state_time = self.get_parent_state_time() self.start_time = self.state_time # add the callback to the schedule delay = self.state_time - now() if delay < 0 or issubclass(self.__class__,RunOnEnter): # parents states (and states like Logging) run immediately delay = 0 if self.interval < 0: # schedule it for every event loop schedule_delayed(self.callback, delay) else: # schedule the interval (0 means once) schedule_delayed_interval(self.callback, delay, self.interval) # say we're active self.active = True # if we don't have the exp reference, get it now if self.exp is None: from experiment import Experiment self.exp = Experiment.last_instance() # custom enter code self._enter() # update the parent time if necessary # moved to after _enter in case we update duration if self.duration > 0: self.advance_parent_state_time(self.duration) pass
def Else(name="ELSE BODY"): """State to attach to the else of an If state. """ # get the exp reference from experiment import Experiment try: exp = Experiment._last_instance() except AttributeError: raise StateConstructionError( "You must first instantiate an Experiment.") # find the parent parent = exp._parents[-1] # find the previous child state (-1 because this is not a state) try: prev_state = parent._children[-1] except IndexError: raise StateConstructionError("No previous state for Else.") # make sure it's the If if not isinstance(prev_state, If): raise StateConstructionError( "The previous state must be an If or Elif state.") # return the false_state (the last out_state) false_state = prev_state._out_states[-1] false_state._name = name false_state.override_instantiation_context() return false_state
# Create a list of columns that won't be used in prediction to drop non_features = [ 'cv_credito', 'coloniaid', 'colonia_num_abd', 'nom_mun', 'mun_region', 'mun_geo_zone', 'year_granted', 'cve', 'abandoned', 'abandoned_y', 'abandoned_ever_y', 'abandon_year', 'abandon_month', 'cur_year', 'past', 'regimen', 'loan_has_subsudy', 'loan_voluntary_contrib_bool', 'personal_gender', 'personal_married', 'loan_building_type' ] # list of features to not convert to quantiles since we are converting all # other features non_quantize_features = ['years_since_granted'] # Create the experiment object exp = Experiment() # Specify the HDF5 file to load data from exp.hdf_file = '/mnt/scratch/master_loan_features_v41.comp.h5' # Specify the years to load exp.load_data_hdf(train_range=(2008, 2014), test_range=(2014, 2015), past=True, all_years=True) # Drop non-feature columns by name exp.drop_cols(non_features) # Drop all columns that have any NA's in them # Can also pass 'row' to drop all rows with NA's in them exp.drop_nas('row')
cnf.one_x_row ], "y": [ cnf.one_digit_per_cell, cnf.one_y_row ], "z": [ cnf.one_digit_per_cell, cnf.one_z_row ], "block": [ cnf.one_digit_per_cell, cnf.block_constraint ] } for experiment_name, constraints in experiments.items(): experiment = Experiment(9, "Image Generation", constraints, "./puzzles/", PycoSatSolver(), None, "./results/") sudoku, statistics = experiment.run_one(sudoku, givens) viz_cube.save_slices(sudoku, experiment_name, "tests") print(statistics) viz_cube.plot_slice(sudoku, 0, 1, save_fig=os.path.join(target_directory, "example_orientation_0.png")) viz_cube.plot_slice(sudoku, 1, 1, save_fig=os.path.join(target_directory, "example_orientation_1.png")) viz_cube.plot_slice(sudoku, 2, 1, save_fig=os.path.join(target_directory, "example_orientation_2.png"))
from __future__ import print_function, division import argparse from experiment import Experiment if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--exp-name', type=str, required=True, help='the name of the json experiment file to run') parser.add_argument( '-overwrite', action='store_true', default=False, help='forces submission of the relevant jobs even if results \ already appear to exist.') parser.add_argument('-debug', action='store_true', default=False, help='prevents actual submission of the jobs') args = parser.parse_args() print('loading experiment', args.exp_name) exp = Experiment(args.exp_name) print('submitting runs') for s in exp.simulations: for e in exp.estimators_and_truth: e.submit_runs(s, overwrite=args.overwrite, debug=args.debug)
model_list.append(BaseMlp(input_dim, output_dim, layers3_1, nn.Linear, name='MLP-3-1').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_2, nn.Linear, name='MLP-3-2').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_3, nn.Linear, name='MLP-3-3').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_4, nn.Linear, name='MLP-3-4').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_1, BibdLinear, name='B-MLP-3-1').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_2, BibdLinear, name='B-MLP-3-2').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_3, BibdLinear, name='B-MLP-3-3').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_4, BibdLinear, name='B-MLP-3-4').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_1, RandomSparseLinear, name='R-MLP-3-1').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_2, RandomSparseLinear, name='R-MLP-3-2').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_3, RandomSparseLinear, name='R-MLP-3-3').to(device)) model_list.append(BaseMlp(input_dim, output_dim, layers3_4, RandomSparseLinear, name='R-MLP-3-4').to(device)) else: print('CUDA is not available. Stopped.') print('model_list: ') for model in model_list: print(' {}'.format(model.name)) experiment = Experiment(n_epoch=10) for model in model_list: experiment.run_model(model, train_loader, validation_loader) # Save all the experiment data filename = 'mlp_experiments_{}.p'.format(date_time) pickle.dump(experiment, open(filename, "wb")) print('The Experiment instance experiment dumped to the file: {}'.format(filename)) print('MLP experiments completed at {}'.format(datetime.now().strftime("%Y%m%d_%H%M%S")))
exp.model.process(exp.task, trial, model = exp.model) records[1] = exp.task.records # Day 1 : GPi OFF exp.model["GPi:cog → THL:cog"].gain = 0 exp.model["GPi:mot → THL:mot"].gain = 0 for trial in exp.task: exp.model.process(exp.task, trial, model = exp.model) records[2] = exp.task.records return records experiment = Experiment(model = "model-topalidou.json", task = "task-topalidou.json", result = "data/experiment-topalidou-protocol-2-new.npy", report = "data/experiment-topalidou-protocol-2-new.txt", n_session = 25, n_block = 3, seed = 533) records = experiment.run(session, "Protocol 2") # Save performance (one column per session) # ----------------------------------------------------------------------------- # P = np.squeeze(records["best"][:,0]) # np.savetxt("data/experiment-topalidou-protocol-2-D1-P.csv", P.T, fmt="%d", delimiter=",") # P = np.squeeze(records["best"][:,1]) # np.savetxt("data/experiment-topalidou-protocol-2-D2-P.csv", P.T, fmt="%d", delimiter=",") # P = np.squeeze(records["best"][:,2]) # np.savetxt("data/experiment-topalidou-protocol-2-D3-P.csv", P.T, fmt="%d", delimiter=",") # P = np.squeeze(records["RT"][:,0]) # np.savetxt("data/experiment-topalidou-protocol-2-D1-RT.csv", P.T, fmt="%.4f", delimiter=",")
def main(): '''LOAD FRIENDS''' active_sensors = [None] * args.batch_size subordinates_batch = [None] * args.batch_size for idx in range(args.batch_size): subordinates = {} if args.use_subordinates: model_strs = [] model_strs.append('Mar-27___12-12-19-RandomPear-recurrent') # BAD PEAR #model_strs.append('Mar-24___16-14-48-RandomPear-recurrent') # GOOD PEAR for s in model_strs: subordinates[s] = Subordinate(s) if idx == 0: print("Loaded subordinate: {}".format(s)) num_subordinates = len(subordinates) if num_subordinates > 0: subordinates_batch[idx] = subordinates policy_sensors = [] if args.use_policy_sensors: model_strs = [] #model_strs.append('Mar-23___14-33-50-RandomPear-recurrent') # BAD PEAR model_strs.append('Mar-24___16-14-48-RandomPear-recurrent') # GOOD PEAR for s in model_strs: policy_sensors.append(PolicySensor(s)) if idx == 0: print("Loaded policy sensor: {}".format(s)) reward_sensors = [] if args.use_reward_sensors: reward_strs = ['pear', 'orange', 'apple'] for s in reward_strs: reward_sensors.append(RewardSensor(s)) if idx == 0: print("Loaded reward sensor: {}".format(s)) if idx == 0: num_active_sensors = len(policy_sensors) + len(reward_sensors) print("Total number of active sensors: {}".format(num_active_sensors)) if num_active_sensors > 0: active_sensors[idx] = policy_sensors + reward_sensors ''' LOAD ENVIRONMENTS ''' print("Creating %d environments" % args.batch_size) from environments.maze.env_list import ENVS Env = ENVS[args.env] print("Environment: {}".format(Env.__name__)) #allowed_actions = range(MC.NUM_BASIC_ACTIONS + num_active_sensors + num_subordinates) policy_dict = {} model_strs = [] #model_strs.append('Mar-23___14-33-50-RandomPear-recurrent') # BAD PEAR #model_strs.append('Mar-27___14-26-20-RandomPear-recurrent') # GOOD PEAR for s in model_strs: print("Loading model: {}".format(s)) filename = os.path.join(C.WORKING_DIR, 'experiments', s, s + '.ckpt') model = RecurrentModel(1, torch.load(filename), filename) policy_dict[s] = DiscreteModelPolicy(model, stochastic=True, baseline_model=None, batch_size=args.batch_size) envs=[Env(active_sensors=active_sensors[idx], subordinates=model_strs, seed=idx) for idx in range(args.batch_size)] A = envs[0].action_space.n action_types = envs[0].world.agent.action_types goal_state = envs[0].reward.goal_state try: E = sum([sensor.shape for sensor in envs[0].world.agent.sensors]) except TypeError: E = None print("Total sensor size: {}".format(E)) state_size_dict = envs[0].world.state_size_dict print("Number of Actions is: {}".format(A)) ''' BUILD MODEL ''' if args.multiprocessing: bs = 1 else: bs = args.batch_size baseline_net = RecurrentNet2(input_size_dict=state_size_dict, hidden_size=20, action_types=["value"], softmax=False, bn=args.bn, wn=args.wn) baseline_model = RecurrentModel(bs, baseline_net) #baseline_model= None _action_net = RecurrentNet2(hidden_size=50, input_size_dict=state_size_dict, action_types=action_types, goal_state=goal_state, bn=args.bn, wn=args.wn) _action_model = RecurrentModel(bs, _action_net) if args.load is not None: print("Loading model: {}".format(args.load)) filename = os.path.join(C.WORKING_DIR, 'experiments', args.load, args.load + '.ckpt') _action_net = torch.load(filename) _action_model = RecurrentModel(1, _action_net, filename) if MC.EXPERIMENTAL and False: policy = DiscreteModelPolicy(_action_model, stochastic=True, baseline_model=baseline_model) policy_dict["main_policy"] = policy policy = CollectionOfPolicies(policy_dict, envs) else: action_model = _action_model policy = DiscreteModelPolicy(action_model, stochastic=True, baseline_model=baseline_model) print("Action model: {}".format(_action_net)) print("Baseline model: {}".format(baseline_net)) optimizer= optim.Adam(policy.parameters(), lr=args.lr) #optimizer= optim.RMSprop(policy.parameters(), lr=args.lr) ''' RUN EXPERIMENT ''' print("Running experiment...") print("There are {} CPUs on this machine".format(multiprocessing.cpu_count())) experiment = Experiment(policy, optimizer, envs, n_train_steps=1000, eval_freq=10, save_freq=50, args=args) experiment._run()
env_name=MergeEnv, network=network, simulator='traci', sim=sim_params, env=env_params, net=net_params, veh=vehicles, initial=initial_config) # # number of time steps flow_params['env'].horizon = 2000 ############ EXPERIMENTS ############## if TEST_SETTINGS: print("this is the test for the environment") from experiment import Experiment exp = Experiment(flow_params) # run the sumo simulation exp.run(num_runs=3, num_cav=(NUM_MERGE_0 + NUM_MERGE_1), num_human=actual_num_human) elif RAY_RL: from ray_rl_setting import * else: from rl_experiments import Experiment exp = Experiment(flow_params) # run the sumo simulation exp.run(num_runs=10,training=TRAINING, \ num_human=NUM_HUMAN, \ actual_num_human = actual_num_human,\
from sklearn import svm # Add pipeline_src to include path (NOTE: this is a hardcoded path... will fail if you move dirs) path = "../pipeline_src/" if not path in sys.path: sys.path.insert(1, path) del path from experiment import Experiment ############################################################################ # Pipeline: Loading & Preprocessing ############################################################################ # Instantiate an experiment exp = Experiment() # Load data & specify train and test ranges # can also specify a list of columns to load with load_list=[] # or a list of columns to drop with drop_list=[] exp.load_data(load_list = [], drop_list = ['abandoned', 'cur_year', 'past'], train_range=(2008,2012), test_range=(2012, 2013), train_current=False, test_current=False, fast=False, all_years=False, head=True) # Create a list of columns that won't be used in prediction to drop
def test_probability_of_hh(): e = Experiment() p = e.flip_coin_2x_n_times(100_000) assert p == approx(0.25, rel=0.01)
def main(): parser = argparse.ArgumentParser(description="Experiment setup") # misc parser.add_argument('--seed', default=33, type=int) parser.add_argument('--gpu', default="", type=str) parser.add_argument('--no_train', default=False, action="store_true") parser.add_argument('--from_model_ckpt', default=None, type=str) parser.add_argument('--rule_thr', default=1e-2, type=float) parser.add_argument('--no_preds', default=False, action="store_true") parser.add_argument('--get_vocab_embed', default=False, action="store_true") parser.add_argument('--exps_dir', default=None, type=str) parser.add_argument('--exp_name', default=None, type=str) # data property parser.add_argument('--datadir', default=None, type=str) parser.add_argument('--resplit', default=False, action="store_true") parser.add_argument('--no_link_percent', default=0., type=float) parser.add_argument('--type_check', default=False, action="store_true") parser.add_argument('--domain_size', default=128, type=int) parser.add_argument('--no_extra_facts', default=False, action="store_true") parser.add_argument('--query_is_language', default=False, action="store_true") parser.add_argument('--vocab_embed_size', default=128, type=int) # model architecture parser.add_argument('--num_step', default=3, type=int) parser.add_argument('--num_layer', default=1, type=int) parser.add_argument('--rank', default=3, type=int) parser.add_argument('--rnn_state_size', default=128, type=int) parser.add_argument('--query_embed_size', default=128, type=int) # optimization parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--print_per_batch', default=3, type=int) parser.add_argument('--max_epoch', default=10, type=int) parser.add_argument('--min_epoch', default=5, type=int) parser.add_argument('--learning_rate', default=0.001, type=float) parser.add_argument('--no_norm', default=False, action="store_true") parser.add_argument('--thr', default=1e-20, type=float) parser.add_argument('--dropout', default=0., type=float) # evaluation parser.add_argument('--get_phead', default=False, action="store_true") parser.add_argument('--adv_rank', default=False, action="store_true") parser.add_argument('--rand_break', default=False, action="store_true") parser.add_argument('--accuracy', default=False, action="store_true") parser.add_argument('--top_k', default=10, type=int) d = vars(parser.parse_args()) option = Option(d) if option.exp_name is None: option.tag = time.strftime("%y-%m-%d-%H-%M") else: option.tag = option.exp_name if option.resplit: assert not option.no_extra_facts if option.accuracy: assert option.top_k == 1 os.environ["CUDA_VISIBLE_DEVICES"] = option.gpu tf.logging.set_verbosity(tf.logging.ERROR) if not option.query_is_language: data = Data(option.datadir, option.seed, option.type_check, option.domain_size, option.no_extra_facts) else: data = DataPlus(option.datadir, option.seed) print("Data prepared.") option.num_entity = data.num_entity option.num_operator = data.num_operator if not option.query_is_language: option.num_query = data.num_query else: option.num_vocab = data.num_vocab option.num_word = data.num_word # the number of words in each query option.this_expsdir = os.path.join(option.exps_dir, option.tag) if not os.path.exists(option.this_expsdir): os.makedirs(option.this_expsdir) option.ckpt_dir = os.path.join(option.this_expsdir, "ckpt") if not os.path.exists(option.ckpt_dir): os.makedirs(option.ckpt_dir) option.model_path = os.path.join(option.ckpt_dir, "model") option.save() print("Option saved.") learner = Learner(option) print("Learner built.") saver = tf.train.Saver(max_to_keep=option.max_epoch) saver = tf.train.Saver() config = tf.ConfigProto() config.gpu_options.allow_growth = False config.log_device_placement = False config.allow_soft_placement = True with tf.Session(config=config) as sess: tf.set_random_seed(option.seed) sess.run(tf.global_variables_initializer()) print("Session initialized.") if option.from_model_ckpt is not None: saver.restore(sess, option.from_model_ckpt) print("Checkpoint restored from model %s" % option.from_model_ckpt) data.reset(option.batch_size) experiment = Experiment(sess, saver, option, learner, data) print("Experiment created.") if not option.no_train: print("Start training...") experiment.train() if not option.no_preds: print("Start getting test predictions...") experiment.get_predictions() if option.get_vocab_embed: print("Start getting vocabulary embedding...") experiment.get_vocab_embedding() experiment.close_log_file() print("=" * 36 + "Finish" + "=" * 36)
rc.RumorCenter(), dc.DistanceCenter(), jc.JordanCenter(), ri.ReverseInfection(), di.DynamicImportance(), prior_detector8, gsba.GSBA(prior_detector1), # gsba_bao7.GSBA_coverage_7(prior_detector1), gsba_bao9.GSBA_coverage_9(prior_detector1), gsba_bao15.GSBA_coverage_15(prior_detector1) ] logger = log.Logger(logname='../data/main_small_world3000.log', loglevel=logging.INFO, logger="experiment").get_log() experiment = Experiment(methods, logger) experiment.propagation_model = 'SI' start_time = clock() print "Starting..." d = data.Graph("../data/small_world/swall-world-graph3000.txt", weighted=0) d.debug = False test_num = 100 print 'Graph size: ', d.graph.number_of_nodes(), d.graph.number_of_edges() test_category = experiment.RANDOM_TEST experiment.start(d, test_category, test_num, 20, 350, 40) # test_category = experiment.FULL_TEST # experiment.start(d, test_category, test_num, 200, 400,100) end_time = clock()
from catboost_experiment import CABExperiment BstExperiment = CABExperiment learning_task = namespace.learning_task train_path = namespace.train test_path = namespace.test cd_path = namespace.cd n_estimators = namespace.n_estimators output_folder_path = os.path.join(namespace.output_folder_path, '') max_hyperopt_evals = namespace.hyperopt_evals print 'Loading and preprocessing dataset...' X_train, y_train, X_test, y_test, cat_cols = Experiment( learning_task, train_path=train_path, test_path=test_path, cd_path=cd_path).read_data() bst_experiment = BstExperiment(learning_task, train_path=train_path, test_path=test_path, cd_path=cd_path, max_hyperopt_evals=max_hyperopt_evals, n_estimators=n_estimators) cv_pairs, (dtrain, dtest) = bst_experiment.split_and_preprocess(X_train.copy(), y_train, X_test.copy(), y_test,
def train(build_model, dataset, hparams, logdir, name, observer, tb_graph): # Check if the given directory already contains model if os.path.exists(f"{logdir}/stats.json"): # then we will load the model weights model_dir = logdir else: # otherwise, create # location to save the model -- <logdir>/<dataset>/<model>/<timestamp> model_dir = os.path.join( logdir, dataset.dataset_name, build_model.__name__, datetime.datetime.now().strftime("%Y%m%d%H%M%S")) os.makedirs(model_dir, exist_ok=True) model_path = os.path.join(model_dir, "weights.h5") # Check if any observers are added for experiment. # If not, add a file_storage observer if observer is None: observer = f"file_storage={model_dir}" # Create an experiment ex = Experiment(name, dataset.dataset_name, build_model.__name__, hparams, observer) # Main function to run for experiment @ex.main def train(_run): # Build model model = build_model(hparams, **dataset.preprocessing.kwargs) # Compile model model.compile(optimizer=optimizers.make_optimizer( hparams.optimizer, hparams.opt_param), loss="categorical_crossentropy", metrics=["categorical_accuracy"]) # Print Summary of models lq.models.summary(model) # If the model already exists, load it and continue training initial_epoch = 0 if os.path.exists(os.path.join(model_dir, "stats.json")): with open(os.path.join(model_dir, "stats.json"), "r") as stats_file: initial_epoch = json.load(stats_file)["epoch"] click.echo( f"Restoring model from {model_path} at epoch = {initial_epoch}" ) model.load_weights(model_path) cb = [callbacks.SaveStats(model_dir=model_dir)] if tb_graph: # If tensorboard logging is enabled, write graph cb.extend([ tf.keras.callbacks.TensorBoard( log_dir=os.path.join(model_dir, "tb"), write_graph=tb_graph, histogram_freq=0, update_freq='epoch', # update_freq=0, profile_batch=0, embeddings_freq=0), ]) # Callback for sending data to Sacred Experiment cb.extend([ tf.keras.callbacks.LambdaCallback( on_epoch_end=lambda epoch, logs: [ ex.log_scalar(metric, value, epoch + 1) for (metric, value) in logs.items() ]) ]) # Train this mode train_log = model.fit( dataset.train_data(hparams.batch_size), epochs=hparams.epochs, steps_per_epoch=dataset.train_examples // hparams.batch_size, validation_data=dataset.validation_data(hparams.batch_size), validation_steps=dataset.validation_examples // hparams.batch_size, initial_epoch=initial_epoch, callbacks=cb) # Execute the experiment ex.execute()
class Ui_MainWindow(object): def createUiElement(self, type, name, parent=None, font=None, alignment=QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing | QtCore.Qt.AlignVCenter, layoutDirection=QtCore.Qt.LeftToRight, maximumSize=None, minimumSize=None, fixedSize=None, isHidden=False, value="", items=[], margins=None): if type == ElementType.Label: uiElement = QtWidgets.QLabel(parent) uiElement.setObjectName(name) uiElement.setText(value) if alignment: uiElement.setAlignment(alignment) if font: uiElement.setFont(font) elif type == ElementType.Value: uiElement = QtWidgets.QLineEdit(parent) uiElement.setLayoutDirection(layoutDirection) uiElement.setText(value) elif type == ElementType.Form: uiElement = QtWidgets.QFormLayout() uiElement.setAlignment(alignment) if margins: uiElement.setContentsMargins(*margins) elif type == ElementType.VBox: if parent: uiElement = QtWidgets.QVBoxLayout(parent) else: uiElement = QtWidgets.QVBoxLayout() if margins: uiElement.setContentsMargins(*margins) elif type == ElementType.HBox: uiElement = QtWidgets.QHBoxLayout() elif type == ElementType.ComboBox: uiElement = QtWidgets.QComboBox(parent) for item in items: uiElement.addItem(item) elif type == ElementType.CheckBox: uiElement = QtWidgets.QCheckBox(parent) uiElement.setLayoutDirection(layoutDirection) elif type == ElementType.Button: uiElement = QtWidgets.QPushButton(parent) else: raise AttributeError("Invalid UI element type") if maximumSize: uiElement.setMaximumSize(maximumSize) if minimumSize: uiElement.setMinimumSize(minimumSize) if fixedSize: uiElement.setFixedSize(*fixedSize) if isHidden: uiElement.setHidden(True) uiElement.setObjectName(name) return uiElement def setupUi(self, mainWindow): self.mainWindow = mainWindow self.mainWindow.setObjectName("mainWindow") self.translate = QtCore.QCoreApplication.translate self.threadpool = QtCore.QThreadPool() self.models = Models() self.statusBar = QtWidgets.QStatusBar(mainWindow) self.statusBar.setObjectName("statusBar") self.statusBar.clearMessage() self.mainWindow.setStatusBar(self.statusBar) self.menuBar = QtWidgets.QMenuBar(mainWindow) self.menuBar.setGeometry(QtCore.QRect(0, 0, 680, 20)) self.menuBar.setObjectName("menuBar") self.mainWindow.setMenuBar(self.menuBar) self.loadNewModelMenu = QtWidgets.QMenu(self.menuBar) self.loadNewModelMenu.setObjectName("loadNewModelMenu") self.actionLoadExecutedModel = QtWidgets.QAction( "actionLoadExecutedModel", mainWindow) self.actionLoadImaginedModel = QtWidgets.QAction( "actionLoadImaginedModel", mainWindow) self.addActions( self.loadNewModelMenu, [self.actionLoadExecutedModel, self.actionLoadImaginedModel]) self.addActions(self.menuBar, [self.loadNewModelMenu.menuAction()]) self.actionLoadExecutedModel.triggered.connect( lambda: self.loadModel(ModelType.Executed)) self.actionLoadImaginedModel.triggered.connect( lambda: self.loadModel(ModelType.Imagined)) self.retranslateUi() self.defineEvents(mainWindow) self.setupSettingsViewUi() def loadModel(self, model_type): if model_type == ModelType.Executed: model_path, _ = QtWidgets.QFileDialog.getOpenFileName( self.mainWindow, 'Load executed model', os.getcwd(), "Model files (*.h5)") elif model_type == ModelType.Imagined: model_path, _ = QtWidgets.QFileDialog.getOpenFileName( self.mainWindow, 'Load imagined model', os.getcwd(), "Model files (*.h5)") else: raise Exception("Invalid model type") if model_path == '': return model_name = model_path[model_path.rfind('/') + len('/'):model_path.rfind('.h5')] try: self.models.add_model(model_name, model_type, model_path) self.displayNewModelNames(self.runTypeComboBox.currentIndex()) except AttributeError: self.displayError("Model with that name is already loaded") except OSError: self.displayError("Model loading failed") def retranslateUi(self): self.loadNewModelMenu.setTitle( self.translate("mainWindow", "Load new model")) self.actionLoadExecutedModel.setText( self.translate("mainWindow", "Load executed task model")) self.actionLoadImaginedModel.setText( self.translate("mainWindow", "Load imagined task model")) def toggleActionsEnabled(self, value): self.actionLoadExecutedModel.setEnabled(value) self.actionLoadImaginedModel.setEnabled(value) def setupSettingsViewUi(self): self.nrOfTasks = None self.subjectId = None self.runType = None self.transferLearningEnabled = None self.selectedModelName = None self.debugMode = None self.showingPredictions = None self.evaluateAllModels = None self.view = ViewType.Settings self.toggleActionsEnabled(True) self.mainWindow.setFixedSize(QtCore.QSize(340, 340)) self.centerOnScreen() self.settingsWidget = QtWidgets.QWidget(self.mainWindow) self.settingsWidget.setMaximumSize(QtCore.QSize(340, 340)) self.settingsWidget.setObjectName("settingsWidget") self.mainWindow.setCentralWidget(self.settingsWidget) self.settingsLayout = self.createUiElement(ElementType.VBox, "settingsLayout", parent=self.settingsWidget, margins=(10, 10, 10, 10)) self.settingsForm = self.createUiElement( ElementType.Form, "settingsForm", parent=self.settingsWidget, alignment=QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter, margins=(10, 10, 10, 10)) self.settingsLayout.addLayout(self.settingsForm) self.settingsLabel = self.createUiElement( ElementType.Label, "settingsLabel", parent=self.settingsWidget, font=QtGui.QFont("Times", 14, QtGui.QFont.Bold), alignment=QtCore.Qt.AlignVCenter) self.settingsForm.addRow(self.settingsLabel) self.subjectIdLabel = self.createUiElement(ElementType.Label, "subjectIdLabel", parent=self.settingsWidget) self.subjectIdValue = self.createUiElement(ElementType.Value, "subjectIdValue", parent=self.settingsWidget, maximumSize=QtCore.QSize( 170, 50), value="1") self.settingsForm.addRow(self.subjectIdLabel, self.subjectIdValue) self.nrOfTasksLabel = self.createUiElement(ElementType.Label, "nrOfTasksLabel", parent=self.settingsWidget) self.nrOfTasksValue = self.createUiElement(ElementType.Value, "nrOfTasksValue", parent=self.settingsWidget, maximumSize=QtCore.QSize( 170, 50), value="16") self.settingsForm.addRow(self.nrOfTasksLabel, self.nrOfTasksValue) self.runTypeComboBoxLabel = self.createUiElement( ElementType.Label, "runTypeComboBoxLabel", parent=self.settingsWidget, ) self.runTypeComboBox = self.createUiElement( ElementType.ComboBox, "runTypeComboBox", parent=self.settingsWidget, maximumSize=QtCore.QSize(170, 50), items=["Executed tasks", "Imagined tasks"]) self.runTypeComboBox.currentIndexChanged.connect( self.displayNewModelNames) self.settingsForm.addRow(self.runTypeComboBoxLabel, self.runTypeComboBox) modelNames = [ model.get_name() for model in self.models.get_models(ModelType.Executed) ] self.modelComboBoxLabel = self.createUiElement( ElementType.Label, "modelComboBoxLabel", parent=self.settingsWidget, ) self.modelComboBox = self.createUiElement(ElementType.ComboBox, "modelComboBox", parent=self.settingsWidget, maximumSize=QtCore.QSize( 170, 50), items=modelNames) self.modelComboBox.currentIndexChanged.connect( self.toggleTransferLearningCheckboxEnabled) self.settingsForm.addRow(self.modelComboBoxLabel, self.modelComboBox) self.showPredictionsCheckboxLabel = self.createUiElement( ElementType.Label, "showPredictionsCheckboxLabel", parent=self.settingsWidget) self.showPredictionsCheckbox = self.createUiElement( ElementType.CheckBox, "showPredictionsCheckbox", parent=self.settingsWidget) self.settingsForm.addRow(self.showPredictionsCheckboxLabel, self.showPredictionsCheckbox) self.transferLearningCheckboxLabel = self.createUiElement( ElementType.Label, "transferLearningCheckboxLabel", parent=self.settingsWidget) self.transferLearningCheckbox = self.createUiElement( ElementType.CheckBox, "transferLearningCheckboxLabel", parent=self.settingsWidget) self.settingsForm.addRow(self.transferLearningCheckboxLabel, self.transferLearningCheckbox) self.evaluateAllModelsLabel = self.createUiElement( ElementType.Label, "evaluateAllModelsLabel", parent=self.settingsWidget) self.evaluateAllModelsCheckBox = self.createUiElement( ElementType.CheckBox, "evaluateAllModelsCheckBox", parent=self.settingsWidget) self.settingsForm.addRow(self.evaluateAllModelsLabel, self.evaluateAllModelsCheckBox) self.debugModeCheckboxLabel = self.createUiElement( ElementType.Label, "debugModeLabel", parent=self.settingsWidget) self.debugModeCheckbox = self.createUiElement( ElementType.CheckBox, "debugModeCheckbox", parent=self.settingsWidget) self.settingsForm.addRow(self.debugModeCheckboxLabel, self.debugModeCheckbox) self.startButton = self.createUiElement(ElementType.Button, "startButton", parent=self.settingsWidget, fixedSize=(320, 40)) self.settingsLayout.addWidget(self.startButton) self.startButton.clicked.connect(self.startExperiment) self.retranslateSettingsView() def displayNewModelNames(self, selectionIndex): self.modelComboBox.clear() model_type = ModelType.Executed if selectionIndex == 0 else ModelType.Imagined self.modelComboBox.addItems( [model.get_name() for model in self.models.get_models(model_type)]) def toggleTransferLearningCheckboxEnabled(self, selectionIndex): if any(tl_model in self.modelComboBox.currentText() for tl_model in ['EEGNet', 'EEGNet_Fusion', 'ShallowConvNet', 'DeepConvNet']): self.transferLearningCheckbox.setEnabled(True) else: self.transferLearningCheckbox.setChecked(False) self.transferLearningCheckbox.setEnabled(False) def retranslateSettingsView(self): self.mainWindow.setWindowTitle( self.translate("mainWindow", "BCI Application v1.0")) self.startButton.setText(self.translate("mainWindow", "Start")) self.settingsLabel.setText(self.translate("mainWindow", "Settings")) self.subjectIdLabel.setText( self.translate("mainWindow", "Current subject ID:")) self.modelComboBoxLabel.setText( self.translate("mainWindow", "Classifier model:")) self.transferLearningCheckboxLabel.setText( self.translate("mainWindow", "Enable transfer learning:")) self.showPredictionsCheckboxLabel.setText( self.translate("mainWindow", "Show predictions:")) self.evaluateAllModelsLabel.setText( self.translate("mainWindow", "Evaluate all models:")) self.debugModeCheckboxLabel.setText( self.translate("mainWindow", "Enable debug mode:")) self.nrOfTasksLabel.setText( self.translate("mainWindow", "Number of tasks to perform:")) self.runTypeComboBoxLabel.setText( self.translate("mainWindow", "Run type:")) def setupExperimentViewUi(self): self.mainWindow.setFixedSize(QtCore.QSize(1024, 768)) self.centerOnScreen() self.view = ViewType.Experiment self.toggleActionsEnabled(False) self.experimentWidget = QtWidgets.QWidget(mainWindow) self.experimentWidget.setMaximumSize(QtCore.QSize(1024, 768)) self.experimentWidget.setObjectName("experimentWidget") self.mainWindow.setCentralWidget(self.experimentWidget) self.experimentLayout = self.createUiElement( ElementType.VBox, "experimentLayout", parent=self.experimentWidget, margins=(10, 10, 10, 10)) self.experimentLabel = self.createUiElement( ElementType.Label, "experimentLabel", parent=self.experimentWidget, font=QtGui.QFont("Roboto", 16, QtGui.QFont.Bold), alignment=QtCore.Qt.AlignVCenter | QtCore.Qt.AlignHCenter, margins=(50, 0, 0, 0)) self.updateExperimentLabel(LabelType.Rest) self.experimentLayout.addWidget(self.experimentLabel) self.graphicsLayout = self.createUiElement( ElementType.HBox, "graphicsLayout", parent=self.experimentWidget) self.experimentLayout.addLayout(self.graphicsLayout) self.experimentGraphic = self.createUiElement( ElementType.Label, "experimentGraphic", parent=self.experimentWidget) self.graphicsLayout.addWidget(self.experimentGraphic) self.stopButton = self.createUiElement(ElementType.Button, "stopButton", parent=self.experimentWidget, fixedSize=(1004, 40)) self.stopButton.setEnabled(False) self.experimentLayout.addWidget(self.stopButton) self.stopButton.clicked.connect(self.experiment.stop) self.taskNrLabel = self.createUiElement(ElementType.Label, "taskNrLabel") self.taskNr = 0 self.updateGraphics(GraphicType.Rest) # show rest state graphics self.retranslateExperimentView('executed' if self.runType == 0 else 'imagined') self.statusBar.showMessage(self.taskNrLabel.text() + str(self.taskNr)) # update status bar def retranslateExperimentView(self, run_type): self.stopButton.setText(self.translate("mainWindow", "Stop")) self.taskNrLabel.setText( self.translate("mainWindow", "Running {} task number: ".format(run_type))) def centerOnScreen(self): resolution = QtWidgets.QDesktopWidget().screenGeometry( ) # TODO: QDesktopWidget deprecated self.mainWindow.move((resolution.width() / 2) - (self.mainWindow.frameSize().width() / 2), (resolution.height() / 2) - (self.mainWindow.frameSize().height() / 2)) def updateTaskNr(self, new_nr): self.taskNr += 1 self.statusBar.showMessage(self.taskNrLabel.text() + str(self.taskNr)) def setupStatisticsViewUi(self): self.mainWindow.setFixedSize(QtCore.QSize(360, 360)) self.centerOnScreen() self.view = ViewType.Statistics self.statistics = self.experiment.get_statistics() self.statisticsWidget = QtWidgets.QWidget(self.mainWindow) self.statisticsWidget.setMaximumSize(QtCore.QSize(360, 340)) self.statisticsWidget.setObjectName("statisticsWidget") self.mainWindow.setCentralWidget(self.statisticsWidget) self.statisticsLayout = self.createUiElement( ElementType.VBox, "statisticsLayout", parent=self.statisticsWidget, margins=(10, 10, 10, 10)) self.statisticsForm = self.createUiElement( ElementType.Form, "statisticsForm", parent=self.statisticsWidget, alignment=QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter, margins=(50, 10, 10, 10)) self.statisticsLayout.addLayout(self.statisticsForm) self.statisticsFormLabel = self.createUiElement( ElementType.Label, "statisticsFormLabel", parent=self.statisticsWidget, font=QtGui.QFont("Times", 14, QtGui.QFont.Bold), alignment=QtCore.Qt.AlignVCenter) self.statisticsForm.addRow(self.statisticsFormLabel) modelType = ModelType.Executed if self.runType == 0 else ModelType.Imagined self.modelSelectionComboboxLabel = self.createUiElement( ElementType.Label, "modelSelectionComboboxLabel", parent=self.statisticsWidget) all_model_names = [ model.get_name() for model in self.models.get_models(modelType) ] model_names = all_model_names if self.evaluateAllModels else [ self.selectedModelName ] self.modelSelectionCombobox = self.createUiElement( ElementType.ComboBox, "modelSelectionCombobox", parent=self.statisticsWidget, maximumSize=QtCore.QSize(160, 50), items=model_names) self.statisticsForm.addRow(self.modelSelectionComboboxLabel, self.modelSelectionCombobox) self.modelSelectionCombobox.currentTextChanged.connect( self.displayNewStatistics) self.runTypeLabel = self.createUiElement(ElementType.Label, "runTypeLabel", parent=self.statisticsWidget) self.runTypeValue = self.createUiElement(ElementType.Label, "runTypeValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.runTypeLabel, self.runTypeValue) self.transferLearningLabel = self.createUiElement( ElementType.Label, "transferLearningLabel", parent=self.statisticsWidget) self.transferLearningValue = self.createUiElement( ElementType.Label, "transferLearningValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.transferLearningLabel, self.transferLearningValue) self.leftHandPredictionsLabel = self.createUiElement( ElementType.Label, "leftHandPredictionsLabel", parent=self.statisticsWidget) self.leftHandPredictionsValue = self.createUiElement( ElementType.Label, "leftHandPredictionsValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.leftHandPredictionsLabel, self.leftHandPredictionsValue) self.rightHandPredictionsLabel = self.createUiElement( ElementType.Label, "rightHandPredictionsLabel", parent=self.statisticsWidget) self.rightHandPredictionsValue = self.createUiElement( ElementType.Label, "rightHandPredictionsValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.rightHandPredictionsLabel, self.rightHandPredictionsValue) self.correctPredictionsLabel = self.createUiElement( ElementType.Label, "correctPredictionsLabel", parent=self.statisticsWidget) self.correctPredictionsValue = self.createUiElement( ElementType.Label, "correctPredictionsValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.correctPredictionsLabel, self.correctPredictionsValue) self.incorrectPredictionsLabel = self.createUiElement( ElementType.Label, "incorrectPredictionsLabel", parent=self.statisticsWidget) self.incorrectPredictionsValue = self.createUiElement( ElementType.Label, "incorrectPredictionsValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.incorrectPredictionsLabel, self.incorrectPredictionsValue) self.totalPredictionsLabel = self.createUiElement( ElementType.Label, "totalPredictionsLabel", parent=self.statisticsWidget) self.totalPredictionsValue = self.createUiElement( ElementType.Label, "totalPredictionsValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.totalPredictionsLabel, self.totalPredictionsValue) self.accuracyLabel = self.createUiElement(ElementType.Label, "accuracyLabel", parent=self.statisticsWidget) self.accuracyValue = self.createUiElement(ElementType.Label, "accuracyValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.accuracyLabel, self.accuracyValue) self.totalRuntimeLabel = self.createUiElement( ElementType.Label, "totalRuntimeLabel", parent=self.statisticsWidget) self.totalRuntimeValue = self.createUiElement( ElementType.Label, "totalRuntimeValue", parent=self.statisticsWidget, alignment=None) self.statisticsForm.addRow(self.totalRuntimeLabel, self.totalRuntimeValue) self.statisticsButtonLayout = self.createUiElement( ElementType.HBox, "statisticsButtonLayout", parent=self.statisticsWidget) self.statisticsLayout.addLayout(self.statisticsButtonLayout) self.reRunExperimentButton = self.createUiElement( ElementType.Button, "reRunExperimentButton", parent=self.statisticsWidget, fixedSize=(150, 40)) self.statisticsButtonLayout.addWidget(self.reRunExperimentButton) self.reRunExperimentButton.clicked.connect(self.startExperiment) self.newExperimentButton = self.createUiElement( ElementType.Button, "newExperimentButton", parent=self.statisticsWidget, fixedSize=(150, 40)) self.statisticsButtonLayout.addWidget(self.newExperimentButton) self.newExperimentButton.clicked.connect(self.setupSettingsViewUi) # By default select and show statistics for the model selected in settings model_index = self.modelSelectionCombobox.findText( self.selectedModelName, QtCore.Qt.MatchFixedString) if model_index >= 0: self.modelSelectionCombobox.setCurrentIndex(model_index) self.displayNewStatistics(self.modelSelectionCombobox.currentText()) self.statusBar.clearMessage() self.retranslateStatisticsView() def retranslateStatisticsView(self): self.statisticsFormLabel.setText( self.translate("mainWindow", "Statistics")) self.modelSelectionComboboxLabel.setText( self.translate("mainWindow", "Show model: ")) self.runTypeLabel.setText( self.translate("mainWindow", "Experiment type: ")) self.transferLearningLabel.setText( self.translate("mainWindow", "Transfer learning used: ")) self.leftHandPredictionsLabel.setText( self.translate("mainWindow", "Left hand predictions:")) self.rightHandPredictionsLabel.setText( self.translate("mainWindow", "Right hand predictions:")) self.correctPredictionsLabel.setText( self.translate("mainWindow", "Correct predictions:")) self.incorrectPredictionsLabel.setText( self.translate("mainWindow", "Incorrect predictions:")) self.totalPredictionsLabel.setText( self.translate("mainWindow", "Total predictions:")) self.accuracyLabel.setText( self.translate("mainWindow", "Prediction accuracy:")) self.totalRuntimeLabel.setText( self.translate("mainWindow", "Experiment run time:")) self.reRunExperimentButton.setText( self.translate("mainWindow", "Run experiment again")) self.newExperimentButton.setText( self.translate("mainWindow", "New experiment")) def displayNewStatistics(self, model_name): model_stats = self.statistics[model_name] runTypeMsg = "Executed movement" if model_stats.get_run_type( ) == 0 else "Imagined movement" self.runTypeValue.setText(runTypeMsg) transferLearningMsg = "Yes" if self.transferLearningEnabled else "No" self.transferLearningValue.setText(transferLearningMsg) leftHandPredictions = str(model_stats.get_left_hand_total()) self.leftHandPredictionsValue.setText(leftHandPredictions) rightHandPredictions = str(model_stats.get_right_hand_total()) self.rightHandPredictionsValue.setText(rightHandPredictions) correctPredictions = str(model_stats.get_correct_total()) self.correctPredictionsValue.setText(correctPredictions) incorrectPredictions = str(model_stats.get_incorrect_total()) self.incorrectPredictionsValue.setText(incorrectPredictions) totalPredictions = str(model_stats.get_total_tasks()) self.totalPredictionsValue.setText(totalPredictions) accuracy = '{:.2%}'.format(model_stats.get_accuracy()) self.accuracyValue.setText(accuracy) minutes, seconds = self.calculate_runtime(model_stats.get_total_time()) totalRuntime = '{} minutes and {} seconds'.format(minutes, seconds) self.totalRuntimeValue.setText(totalRuntime) def calculate_runtime(self, runtime): minutes = int(runtime / 60) seconds = int(runtime - minutes * 60) return minutes, seconds def addActions(self, item, actions): for action in actions: item.addAction(action) def defineEvents(self, mainWindow): QtCore.QMetaObject.connectSlotsByName(mainWindow) def exitGracefully(self): self.stopExperiment(quitCalled=True) sys.exit() def startExperiment(self): try: self.validateInputFields() except AssertionError: self.displayError("Please fill all input fields") return except AttributeError: self.displayError("Input fields must be positive integers") return self.runType = self.runType if self.runType != None else self.runTypeComboBox.currentIndex( ) self.transferLearningEnabled = self.transferLearningEnabled if self.transferLearningEnabled != None else self.transferLearningCheckbox.isChecked( ) self.showingPredictions = self.showingPredictions if self.showingPredictions != None else self.showPredictionsCheckbox.isChecked( ) self.selectedModelName = self.selectedModelName if self.selectedModelName != None else str( self.modelComboBox.currentText()) self.debugMode = self.debugMode if self.debugMode != None else self.debugModeCheckbox.isChecked( ) self.models.set_selected(self.runType, self.selectedModelName) self.evaluateAllModels = self.evaluateAllModels if self.evaluateAllModels != None else self.evaluateAllModelsCheckBox.isChecked( ) selectedModel = self.models.get_selected() if self.evaluateAllModels: modelType = ModelType.Executed if self.runType == 0 else ModelType.Imagined models = self.models.get_models(modelType) else: models = [selectedModel] self.experiment = Experiment(self.subjectId, self.runType, selectedModel, self.nrOfTasks, self.showingPredictions, self.transferLearningEnabled, self.debugMode, models) self.setupExperimentViewUi() try: self.runExperiment() except Exception as e: self.handleException(e) def validateInputFields(self): if (not self.nrOfTasks \ or not self.subjectId) \ and (not self.nrOfTasksValue.text() \ or not self.subjectIdValue.text()): raise AssertionError if not self.nrOfTasks or not self.subjectId: try: nrOfTasks = int(self.nrOfTasksValue.text()) subjectId = int(self.subjectIdValue.text()) if nrOfTasks < 1 or subjectId < 1: raise AttributeError self.nrOfTasks = nrOfTasks self.subjectId = subjectId except: raise AttributeError def displayError(self, message): QtWidgets.QMessageBox.critical(self.mainWindow, "Error", message) def handleException(self, exception): exc_type, msg, trace = exception print(trace) self.displayError(str(msg)) def stopExperiment(self, quitCalled=False): if not hasattr(self, 'experiment'): return self.threadpool.waitForDone(1) self.experiment.stop() self.experiment.set_run_time(time.time() - self.experimentStartTime) if quitCalled: return self.setupStatisticsViewUi() if self.transferLearningEnabled: self.transferLearningRunning(True) try: worker = Worker(self.experiment.apply_transfer_learning) worker.signals.finished.connect( self.onTransferLearningFinished) worker.signals.error.connect(self.onTransferLearningFinished) self.threadpool.start(worker) except Exception as e: self.handleException(e) def onTransferLearningFinished(self): self.transferLearningRunning(False) def runExperiment(self): worker = Worker(self.experiment.run) worker.signals.progress.connect(self.determineExperimentAction) worker.signals.error.connect(self.handleException) worker.signals.finished.connect(self.stopExperiment) self.threadpool.start(worker) self.experimentStartTime = time.time() def determineExperimentAction(self, *args): if self.view != ViewType.Experiment: return task, progress_type = args[0] if progress_type == ProgressType.TaskStart: self.updateExperimentUi(task) self.stopButton.setEnabled(True) elif progress_type == ProgressType.TaskResult: if self.showingPredictions: self.showPrediction(task) else: self.showRest() else: raise Exception("Invalid progress type") def showRest(self): self.updateExperimentLabel(LabelType.Rest) self.updateGraphics(GraphicType.Rest) def transferLearningRunning(self, running): self.reRunExperimentButton.setEnabled(not running) self.newExperimentButton.setEnabled(not running) if running: msg = "Running transfer learning. Please wait..." else: msg = "Transfer learning finished" self.statusBar.showMessage(msg) def updateExperimentUi(self, task): self.updateExperimentLabel(LabelType.Task) self.updateTaskNr(task.get_task_nr()) graphic_type = GraphicType.LeftTask if task.get_task_type( ) == 0 else GraphicType.RightTask self.updateGraphics(graphic_type) def showPrediction(self, task): task_label = task.get_task_type() prediction = task.get_majority_prediction() if prediction == 0 and task_label == prediction: self.updateGraphics(GraphicType.LeftCorrectPrediction) elif prediction == 0 and task_label != prediction: self.updateGraphics(GraphicType.LeftIncorrectPrediction) elif prediction == 1 and task_label == prediction: self.updateGraphics(GraphicType.RightCorrectPrediction) elif prediction == 1 and task_label != prediction: self.updateGraphics(GraphicType.RightIncorrectPrediction) else: raise AttributeError( "Invalid prediction value {}".format(prediction)) self.updateExperimentLabel(LabelType.Prediction) def updateExperimentLabel(self, labelType): if labelType == LabelType.Prediction: self.experimentLabel.setText( "The model predicts that the previous task was") elif labelType == LabelType.Task: self.experimentLabel.setText( "Please perform the task indicated by the circle") elif labelType == LabelType.Rest: self.experimentLabel.setText("Please rest before the next task") else: raise AttributeError("Invalid label type") def updateGraphics(self, graphic_type): pixmap = self.getTaskGraphic(graphic_type) self.experimentGraphic.setPixmap(pixmap) def getTaskGraphic(self, graphic_type): file_locations = { GraphicType.LeftTask: "./images/circle_left.jpg", GraphicType.RightTask: "./images/circle_right.jpg", GraphicType.Rest: "./images/blank.jpg", GraphicType.LeftCorrectPrediction: "./images/circle_left_correct.jpg", GraphicType.RightCorrectPrediction: "./images/circle_right_correct.jpg", GraphicType.LeftIncorrectPrediction: "./images/circle_left_incorrect.jpg", GraphicType.RightIncorrectPrediction: "./images/circle_right_incorrect.jpg" } return QtGui.QPixmap(file_locations.get(graphic_type))
def main(): NAME = None LAYER_SIZES = None C_VECTOR = None # list of digits or the string 'crossLipschitz' RANDOM_SEED = None RADIUS = None MNIST_DIGITS = None FREQUENCY = None EPOCHS = None assert all([_ is not None for _ in [NAME, LAYER_SIZES, C_VECTOR, RANDOM_SEED, RADIUS, FREQUENCY, EPOCHS]]) exp_kwargs = {'c_vector': C_VECTOR, 'primal_norm': 'linf'} DIMENSION = 784 GLOBAL_LO = np.zeros(DIMENSION) GLOBAL_HI = np.ones(DIMENSION) DOMAIN = Hyperbox.build_unit_hypercube(DIMENSION) BALL_FACTORY = Factory(Hyperbox.build_linf_ball, radius=RADIUS) NAMER = lambda epoch_no: '%s_EPOCH%04d' % (NAME, epoch_no) # ================================================================ # = Data Parameters Setup = # ================================================================ # Make both the training/validation sets train_set = dl.load_mnist_data('train', digits=MNIST_DIGITS) val_set = dl.load_mnist_data('val', digits=MNIST_DIGITS) # Make the data arg_bundle object loader_kwargs = {'batch_size': 100, 'digits': MNIST_DIGITS, 'shuffle': True} train_arg_bundle = {'data_type': 'MNIST', 'loader_kwargs': loader_kwargs, 'ball_factory': BALL_FACTORY, 'train_or_val': 'train'} val_arg_bundle = {'data_type': 'MNIST', 'loader_kwargs': loader_kwargs, 'ball_factory': BALL_FACTORY, 'train_or_val': 'val'} # ================================================================ # = Training Parameter Setup = # ================================================================ # Build the loss functional and set the optimizer xentropy = train.XEntropyReg() l2_penalty = train.LpWeightReg(scalar=1e-2, lp='l2') loss_functional = train.LossFunctional(regularizers=[xentropy]) train_params = train.TrainParameters(train_set, train_set, EPOCHS, loss_functional=loss_functional, test_after_epoch=20) # Build the base network architecture network = ReLUNet(layer_sizes=LAYER_SIZES) # ================================================================ # = Build the Experiment objects = # ================================================================ local_exp = Experiment([FastLip, LipLP, LipMIP], network=network, **exp_kwargs) global_exp = Experiment(GLOBAL_METHODS, network=network, **exp_kwargs) # ================================================================ # = Build the methodNests = # ================================================================ # --- randomly evaluated method nest random_nest = MethodNest(Experiment.do_random_evals, {'sample_domain': DOMAIN, 'ball_factory': BALL_FACTORY, 'num_random_points': 20}) # --- data-based method nest train_nest = MethodNest(Experiment.do_data_evals, train_arg_bundle) val_nest = MethodNest(Experiment.do_data_evals, val_arg_bundle) # --- hypercube stuff cube_nest = MethodNest(Experiment.do_unit_hypercube_eval) local_nests = [random_nest, train_nest, val_nest, cube_nest] global_nests = [cube_nest] def build_jobs(epoch_no, network=None): local_job_name = NAMER(epoch_no) + '_LOCAL' local_job = Job(local_job_name, local_exp, local_nests, save_loc=SCHEDULE_DIR) local_job.write() global_job_name = NAMER(epoch_no) + '_GLOBAL' global_job = Job(global_job_name, global_exp, global_nests, save_loc=SCHEDULE_DIR) global_job.write() if FREQUENCY is None: job_do_every = None else: job_do_every = DoEvery(build_jobs, FREQUENCY) # ============================================================== # = Train the network = # ============================================================== train.training_loop(network, train_params, epoch_callback=job_do_every) if FREQUENCY is None: build_jobs(EPOCHS)
help='portion of training data') parser.add_argument('--unrolled', action='store_true', default=False, help='use one-step unrolled validation loss') parser.add_argument('--arch_learning_rate', type=float, default=6e-4, help='learning rate for arch encoding') parser.add_argument('--arch_weight_decay', type=float, default=1e-3, help='weight decay for arch encoding') # new hyperparams. parser.add_argument('--weight_lambda', type=float, default=1.0) parser.add_argument('--pretrain_steps', type=int, default=0) args = parser.parse_args() assert args.unrolled == False and '--unrolled not supported!' assert args.train_portion == 0.5 and '--train_portion not supported!' # Main Driver for your code. Either run `python main.py` which will run the experiment with default config # or specify the configuration by running `python main.py custom` if __name__ == "__main__": exp_name = args.save print("Running Experiment: ", exp_name) exp = Experiment(args) exp.run() # exp.test()
self._log_attrs.extend(['push_val', 'push_time']) def _callback(self): if type(self._push_val) != list: self._server.push_sample([self._push_val]) else: self._server.push_sample(self._push_val) self._push_time = clock.now() if __name__ == "__main__": from experiment import Experiment exp = Experiment() # Initialize the outlet OUTLET = init_lsl_outlet(server_name='MarkerStream', server_type='Markers', nchans=1, suggested_freq=500, channel_format='int32', unique_id='SMILE_LSL_OUT') # Signal the beginning of the experiment. LSLPush(server=OUTLET, val=55) # Wait for the experiment to start! Wait(2.)
import numpy as np import membership import tnorms import implications from experiment import Experiment #Antecedents a1 = [] #Consequents b1 = [] #Input inp = [] for i in np.arange(0,10,0.01): a1.append(membership.triang(i,1,4,7)) b1.append(membership.triang(i,1,3,5)) inp.append(membership.triang(i,2,3,4)) name = "exp1" description = "first test" tnorm = tnorms.minimum implication = implications.godel experiment = Experiment(name, description, inp, a1, b1, tnorm, implication) experiment.run_full_experiment()
def test_probability_of_a_head(): e = Experiment() p = e.flip_coin_x_times(100_000) assert p == approx(0.5, rel=0.01)
gamma = None try: batch_size = params["method"]["batch_size"] except KeyError: batch_size = None if save_folder is not None and not os.path.exists(save_folder): os.makedirs(save_folder) with open(os.path.join(params["logging"]["save_folder"], "config.yml"), 'w') as f: yaml.dump(params, f) experiment = Experiment( n=params["task"]["matrix"]["n"], kappa=params["task"]["matrix"]["kappa"], scale=params["task"]["scale"], alpha=params["method"]["alpha"], beta=params["method"]["beta"], tau=tau, gamma=gamma, batch_size=batch_size, save_folder=save_folder, ) print(experiment.__dict__) experiment.run(num_iters=params["method"]["num_iters"]) print("Training is completed.")
parser.add_argument('--beta1', type=float, default=0.9) parser.add_argument('--beta2', type=float, default=0.999) parser.add_argument('--weight_decay', type=float, default=0.) # misc parser.add_argument('--device', type=str, default='cpu') parser.add_argument('--log_dir', type=str, default='logs') parser.add_argument('--exp_name', type=str, default='garbage') args, unknown_args = parser.parse_known_args() args.data_A_dir = './data/horse2zebra/trainA' args.data_B_dir = './data/horse2zebra/trainB' args.batch_size = 1 args.train_iters = int(1e+9) args.use_lsgan = True args.lr = 2e-4 args.beta1 = 0.5 args.device = 'cuda:0' args.exp_name = 'exp0.4' args.log_report_freq = 10 args.scalar_report_freq = 10 args.image_report_freq = 10 args.log_dir = os.path.join(args.log_dir, args.exp_name) if os.path.exists(args.log_dir): raise OSError('`{}` already exists.'.format(args.log_dir)) else: os.makedirs(args.log_dir) Experiment(args).run()
import logging import fire import constants from experiment import Experiment logging.basicConfig(format=constants.LOG_FORMAT) logging.getLogger(constants.LOGGER_NAME).setLevel(logging.INFO) # the func below is a wrapped because of some python-fire docstrings issues experiment = Experiment() if __name__ == "__main__": fire_experiment = fire.Fire(Experiment())
def main(): parser = argparse.ArgumentParser(description="Experiment setup") # misc parser.add_argument('--seed', default=33, type=int) parser.add_argument('--gpu', default="", type=str) parser.add_argument('--no_train', default=False, action="store_true") parser.add_argument('--from_model_ckpt', default=None, type=str) parser.add_argument('--no_rules', default=False, action="store_true") parser.add_argument('--rule_thr', default=1e-2, type=float) parser.add_argument('--no_preds', default=False, action="store_true") parser.add_argument('--get_vocab_embed', default=False, action="store_true") parser.add_argument('--exps_dir', default='exps', type=str) parser.add_argument('--exp_name', default=None, type=str) parser.add_argument('--load', default=None, type=str) # data property parser.add_argument('--datadir', default=None, type=str) parser.add_argument('--resplit', default=False, action="store_true") parser.add_argument('--no_link_percent', default=0., type=float) parser.add_argument('--type_check', default=False, action="store_true") parser.add_argument('--domain_size', default=128, type=int) parser.add_argument('--no_extra_facts', default=False, action="store_true") parser.add_argument('--query_is_language', default=False, action="store_true") parser.add_argument('--vocab_embed_size', default=128, type=int) # model architecture parser.add_argument('--num_step', default=4, type=int) parser.add_argument('--num_layer', default=1, type=int) parser.add_argument('--rnn_state_size', default=128, type=int) parser.add_argument('--query_embed_size', default=128, type=int) # optimization parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--print_per_batch', default=3, type=int) parser.add_argument('--max_epoch', default=200, type=int) parser.add_argument('--min_epoch', default=100, type=int) parser.add_argument('--learning_rate', default=0.001, type=float) parser.add_argument('--no_norm', default=False, action="store_true") parser.add_argument('--no_cuda', default=False, action="store_true") parser.add_argument('--thr', default=1e-20, type=float) parser.add_argument('--dropout', default=0., type=float) # evaluation parser.add_argument('--get_phead', default=False, action="store_true") parser.add_argument('--adv_rank', default=False, action="store_true") parser.add_argument('--rand_break', default=False, action="store_true") parser.add_argument('--accuracy', default=False, action="store_true") parser.add_argument('--top_k', default=10, type=int) d = vars(parser.parse_args()) option = Option(d) random.seed(option.seed) np.random.seed(option.seed) torch.manual_seed(option.seed) load_fn = 'data.mat' load_data = sio.loadmat(load_fn) blood_oxygen = load_data['value1'] # ndarray speed = load_data['value2'] # ndarray labels = load_data['state'] labels = (labels - np.min(labels)) * 1.0 / (np.max(labels) - np.min(labels)) labels = labels.reshape(-1) data = {} trainn = 270 print labels.shape data['train_edge1'] = blood_oxygen[:trainn] data['train_edge2'] = speed[:trainn] data['train_labels'] = labels[:trainn] data['valid_edge1'] = blood_oxygen[trainn:] data['valid_edge2'] = speed[trainn:] data['valid_labels'] = labels[trainn:] # 300*N,N, 300,N,N 300,1 if option.exp_name is None: option.tag = time.strftime("%y-%m-%d-%H-%M") else: option.tag = option.exp_name option.this_expsdir = os.path.join(option.exps_dir, option.tag) if not os.path.exists(option.this_expsdir): os.makedirs(option.this_expsdir) option.ckpt_dir = os.path.join(option.this_expsdir, "ckpt") if not os.path.exists(option.ckpt_dir): os.makedirs(option.ckpt_dir) option.model_path = os.path.join(option.ckpt_dir, "model") option.save() print("Option saved.") # learner = Learner(option) device = torch.device( "cuda" if torch.cuda.is_available() and not option.no_cuda else "cpu") n_gpu = torch.cuda.device_count() # learner = CNN(option) learner = StackedGAT(option) # learner = BrainGraph(option) learner.to(device) # learner = nn.DataParallel(learner, [0,1,2]) if option.load is not None: with open(option.load, 'rb') as f: learner.load_state_dict(torch.load(f)) experiment = Experiment(option, device, learner=learner, data=data) print("Experiment created.") if not option.no_train: print("Start training...") experiment.train() if not option.no_preds: print("Start getting test predictions...") experiment.get_predictions() # saver = tf.train.Saver(max_to_keep=option.max_epoch) # saver = tf.train.Saver() # config = tf.ConfigProto() # config.gpu_options.allow_growth = False # config.log_device_placement = False # config.allow_soft_placement = True # with tf.Session(config=config) as sess: # tf.set_random_seed(option.seed) # sess.run(tf.global_variables_initializer()) # print("Session initialized.") # if option.from_model_ckpt is not None: # saver.restore(sess, option.from_model_ckpt) # print("Checkpoint restored from model %s" % option.from_model_ckpt) # data.reset(option.batch_size) # experiment = Experiment(sess, saver, option, learner, data) # print("Experiment created.") # if not option.no_train: # print("Start training...") # experiment.train() # # if not option.no_preds: # print("Start getting test predictions...") # experiment.get_predictions() # # if not option.no_rules: # print("Start getting rules...") # experiment.get_rules() # if option.get_vocab_embed: # print("Start getting vocabulary embedding...") # experiment.get_vocab_embedding() # # experiment.close_log_file() print("=" * 36 + "Finish" + "=" * 36)
exp.model["CTX:cog → STR:cog"].gain = g1 for trial in exp.task.block(0): exp.model.process(exp.task, trial) records[1] = exp.task.records return records mdl = "model-topalidou-thomas.json" tsk = "tasks/task-topalidou.json" rslt = folderRes + "protocol-NoStrCog.npy" rprt = folderRep + "protocol-NoStrCog.txt" experiment = Experiment(model=mdl, task=tsk, result=rslt, report=rprt, n_session=25, n_block=2, seed=377) records = experiment.run(session, "Thomas Protocol No Str Cog") # Textual results # ----------------------------------------------------------------------------- P = np.squeeze(records["best"][:, 0, :25]) * 100 P = P.mean(axis=len(P.shape) - 1) print("D1 start: %.3f ± %.3f" % (P.mean(), P.std())) P = np.squeeze(records["best"][:, 0, -25:]) * 100 P = P.mean(axis=len(P.shape) - 1) print("D1 end: %.3f ± %.3f" % (P.mean(), P.std())) print()
def test_probability_of_ththh(): e = Experiment() p = e.flip_coin_with_pattern_n_times([0, 1, 0, 1, 1], 1_000_000, 5) assert p == approx((0.5)**5, rel=0.01)
mdl = "model-topalidou.json" #revr = [10,20,30,40,50,60,70,80,90,100,200,300,400,500] revr = 200 dt = "data_new" fdl = "reverse" + str(revr) + "-sessions" trial = str(revr) tsk = "tasks/task-topalidou-reverse-" + trial + ".json" rslt = dt + "/results/reverse-NoCtx/experiment-topalidou-reverse-" + trial + ".npy" # rprt = dt + "/reports/reverse-NoCtx/experiment-topalidou-reverse-" + trial + ".txt" # experiment = Experiment(model=mdl, task=tsk, result=rslt, report=rprt, n_session=25, n_block=1, seed=123) #None) records = experiment.run(session, "Protocol Reverse") records = np.squeeze(records) # ----------------------------------------------------------------------------- for session in range(25): xlims = 1000 #session = 0 P_mean = records["best"][session, :xlims] Rwrd_mean = records["reward"][session, :xlims]
def test_probability_of_hhhh(): e = Experiment() p = e.flip_coin_with_pattern_n_times([1, 1, 1, 1], 1_000_000, 4, 0.3) assert p == approx((0.3)**4, rel=0.01)
def test_probability_of_odd_3_4_less_3(): e = Experiment() pattern = [[1, 3, 5], [3], [4], [1, 2]] p = e.roll_die_with_pattern_n_times(pattern, 1_000_000, 4, (0.3, 0.05, 0.05, 0.3, 0.1, 0.2)) assert p == approx(.45 * .05 * .30 * .35, rel=0.02)
if performance > best_performance: best_performance = performance print('best performance is %.3f' % (performance)) torch.save(model.state_dict(), model_path) model.train() parser = argparse.ArgumentParser(description="train script") parser.add_argument('exp_name') parser.add_argument('--debug', action='store_true', help='verbose mode') args = parser.parse_args() if args.debug: print('warning ... excute in debug mode') expe = Experiment('debug/pointwise/answer_doc') else: expe = Experiment(args.exp_name) config = expe.config print_to_tee(expe.train_log_path) sample_stg = sample_strategy_factory(config.SAMPLE_STG_NAME, k=config.NEG_SAMPLE_NUM) print('load examples') train_examples = load_examples_from_scratch(config.TRAIN_PATH, sample_stg, concat=True) print('build model')
BATCH_SIZE = 1 NO_OF_EPOCHS = 200 input_shape = (224, 224, 3) lr = 1E-4 # pre-trained model load = False # load = 'results/ckpt/FCN_Vgg16_32s_best_model_1.h5' train_gen = data_generation(img_dir_path=train_frame_path, batch_size=BATCH_SIZE, inputshape=input_shape, labels_dir_path=train_mask_path) val_gen = data_generation(img_dir_path=val_frame_path, batch_size=BATCH_SIZE, inputshape=input_shape, labels_dir_path=val_mask_path) experiment_object = Experiment(inputshape=input_shape, learning_rate=lr, train_gen=train_gen, val_gen=val_gen) STEP_PER_EPOCH = (len(os.listdir(train_frame_path)) // BATCH_SIZE) VAL_STEPS = (len(os.listdir(val_frame_path)) // BATCH_SIZE) config = tf.compat.v1.ConfigProto(gpu_options= tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=0.8) # device_count = {'GPU': 1} ) config.gpu_options.allow_growth = True session = tf.compat.v1.Session(config=config) tf.compat.v1.keras.backend.set_session(session) experiment_object.train_model(epochs=NO_OF_EPOCHS, validation_steps=VAL_STEPS, pretrained_weights=load, steps_per_epoch=STEP_PER_EPOCH) print('*****Renaming File*****')