def main_loop(self): """ Perform maintenance operations. The main operation is routing table maintenance where staled nodes are added/probed/replaced/removed as needed. The routing management module specifies the implementation details. This includes keeping track of queries that have not been responded for a long time (timeout) with the help of querier.Querier. The routing manager and the lookup manager will be informed of those timeouts. This method is designed to be used as minitwisted's heartbeat handler. """ queries_to_send = [] current_ts = time.time() #TODO: I think this if should be removed # At most, 1 second between calls to main_loop after the first call if current_ts >= self._next_main_loop_call_ts: self._next_main_loop_call_ts = current_ts + 1 else: # It's too early return self._next_main_loop_call_ts, [] # Retry failed lookup (if any) queries_to_send.extend(self._try_do_lookup()) # Take care of timeouts if current_ts >= self._next_timeout_ts: (self._next_timeout_ts, timeout_queries) = self._querier.get_timeout_queries() for query in timeout_queries: queries_to_send.extend(self._on_timeout(query)) # Routing table maintenance if time.time() >= self._next_maintenance_ts: (maintenance_delay, queries, maintenance_lookup) = self._routing_m.do_maintenance() self._next_maintenance_ts = current_ts + maintenance_delay self._next_main_loop_call_ts = min(self._next_main_loop_call_ts, self._next_maintenance_ts) queries_to_send.extend(queries) if maintenance_lookup: target, rnodes = maintenance_lookup lookup_obj = self._lookup_m.maintenance_lookup(target) queries_to_send.extend(lookup_obj.start(rnodes)) # Auto-save routing table if current_ts >= self._next_save_state_ts: state.save(self._my_id, self._routing_m.get_main_rnodes(), self.state_filename) self._next_save_state_ts = current_ts + SAVE_STATE_DELAY self._next_main_loop_call_ts = min(self._next_main_loop_call_ts, self._next_maintenance_ts, self._next_timeout_ts, self._next_save_state_ts) # Return control to reactor datagrams_to_send = self._register_queries(queries_to_send) return self._next_main_loop_call_ts, datagrams_to_send
def test_load_save_state(self): filename = "test_logs/state.dat" my_id = tc.CLIENT_ID # TODO: change state state.save(my_id, [], filename) # TODO:check file state.load(filename)
def init(): global controls, cursor, point, cps controls = [ parts.Conduit((1,)), parts.Conduit((2,)), parts.Conduit((3,)), parts.Conduit((1,2,)), parts.Conduit((1,3,)), parts.Conduit((2,3,)), ] cps = [ F(854 - 130 + 90 * (j % 3 - 1) - 25, 80 + 100 * (j // 3), 50) for j in range(len(controls)) ] del buttons[:] buttons.append(button.Button("Remove All", F(720, 390, 120, 30), fontsize = F(22))) buttons.append(button.Button("Depart", F(720, 430, 120, 30), fontsize = F(22))) buttons.extend( button.Button("buy" + s, (x - F(15), y + F(55), F(80), F(40)), fontsize = F(14)) for (x, y, _), s in zip(cps, "1 2 3 12 13 23".split()) ) for j, modulename in enumerate(state.state.available): controls.append(parts.Module(modulename)) cps.append((mx0 + F(85) * (j // 4), my0 + F(85) * (j % 4), mscale)) cursor = None point = None gamescene.setshroud((0,0,0)) state.state.you.hp = state.state.you.maxhp state.save()
def predict(): saved = state.load('model') #saved = None if debug_mode: saved = None if saved == None: train, y, test, _ = data.get() ftrain, ftest, _ = fea_1.get() ftrain2, ftest2, _ = fea_2.get() train = pd.concat([train, ftrain, ftrain2], axis=1) test = pd.concat([test, ftest, ftest2], axis=1) print(train.shape, test.shape) z = pd.DataFrame() z['id'] = test.id z['y'] = 0 v = pd.DataFrame() v['id'] = train.id v['y'] = y cv, _ = run(train, y, test, v, z) state.save('model', (v, z, cv, None)) else: v, z, cv, _ = saved return v, z, cv, _
def update(self, events): ''' Updates the screen when an event happens @param - list of game events ''' for event in events: if not hasattr(event, 'key'): continue if event.type == KEYDOWN: if event.key == K_p: State.pop_screen() elif event.key == K_RETURN: self.sounds['select'].play() if self.currLine == PauseScreenLines.Resume: State.pop_screen() if self.currLine == PauseScreenLines.Save: self.tileMap.save(self.player) save(USER_SAVES_DIR + State.save_name) elif self.currLine == PauseScreenLines.Quit: State.pop_screen() State.pop_screen() elif event.key == K_i: State.push_screen(InventoryScreen(self.player)) else: super(PauseScreen, self).interact(event)
def test_load_save_state(self): filename = 'test_logs/state.dat' my_id = tc.CLIENT_ID #TODO: change state state.save(my_id, [], filename) #TODO:check file state.load(filename)
def check_events(): """ Check android-specific pause event. """ if android.check_pause(): android.hide_keyboard() # save emulator state state.console_state.screen.save_state() state.save() state.console_state.screen.clear_saved_state() # hibernate; we may not wake up android.wait_for_resume() return True return False
def handleclick(): global cursor if isinstance(point, tuple): if cursor: icon = cursor.nearest(point) if state.state.canaddpart(icon): state.state.addpart(icon) sound.play("build") cursor = None else: sound.play("cantbuild") else: part = state.state.partat(map(int, point)) if part: state.state.removepart(part) sound.play("unbuild") elif isinstance(point, basestring): if point == "Remove All": state.state.removeall() sound.play("unbuild") elif point == "Depart" and state.state.cango(): scene.pop() gamescene.makebuttons() elif point.startswith("buy"): cname = "conduit-" + point[3:] state.state.buy(cname) elif isinstance(point, parts.Conduit): if cursor is point: for j in range(len(controls)): if controls[j] is cursor: controls[j] = cursor = cursor.rotate(1) elif state.state.unused[point.name]: cursor = point else: sound.play("cantpick") elif isinstance(point, parts.Part): if cursor is point: cursor = None elif point.name in state.state.unlocked: if state.state.unused[point.name]: cursor = point else: sound.play("cantpick") else: state.state.unlock(point.name) elif point is None: cursor = None state.save()
def predict(): saved = state.load('model') #saved = None if saved == None: train, y, test, _ = data.get() z = pd.DataFrame() z['id'] = test.id z['y'] = 0 v = pd.DataFrame() v['id'] = train.id v['y'] = y cv, _ = run(train, y, test, v, z) state.save('model', (v, z, cv, None)) else: v, z, cv, _ = saved return v, z, cv, _
def run(self, command, run, quit, wait): """ Interactive interpreter session. """ if command: self.store_line(command) self.loop() if run: # position the pointer at start of program and enter execute mode flow.jump(None) state.basic_state.parse_mode = True state.console_state.screen.cursor.reset_visibility() try: try: while True: self.loop() if quit and state.console_state.keyb.buf.is_empty(): break except error.Exit: # pause before exit if requested if wait: signals.video_queue.put(signals.Event(signals.VIDEO_SET_CAPTION, 'Press a key to close window')) signals.video_queue.put(signals.Event(signals.VIDEO_SHOW_CURSOR, False)) state.console_state.keyb.pause = True # this performs a blocking keystroke read if in pause state events.check_events() finally: # close interfaces signals.video_queue.put(signals.Event(signals.VIDEO_QUIT)) signals.message_queue.put(signals.Event(signals.AUDIO_QUIT)) # persist unplayed tones in sound queue state.console_state.tone_queue_store = [ signals.save_queue(q) for q in signals.tone_queue] state.save() # close files if we opened any devices.close_files() devices.close_devices() except error.Reset: # delete state if resetting state.delete()
def start_basic(): """ Load & run programs and commands and hand over to interactive mode. """ import program import run import error import state import devices import disk import cassette import reset import sound import audio do_reset = False backend, console = None, None exit_error = '' try: # resume from saved emulator state if requested and available resume = config.get('resume') and state.load() # choose the video and sound backends backend, console = prepare_console() # greet, load and run only if not resuming if resume: # override selected settings from command line cassette.override() disk.override() # suppress double prompt if not state.basic_state.execute_mode: state.basic_state.prompt = False run.start('', False, config.get('quit')) else: # load/run program config.options['run'] = config.get(0) or config.get('run') prog = config.get('run') or config.get('load') if prog: # on load, accept capitalised versions and default extension with open_native_or_dos_filename(prog) as progfile: program.load(progfile) reset.clear() print_greeting(console) # start the interpreter (and get out if we ran with -q) run.start(config.get('exec'), config.get('run'), config.get('quit')) except error.RunError as e: exit_error = e.message except error.Exit: # pause before exit if requested if config.get('wait'): backend.video_queue.put( backend.Event(backend.VIDEO_SET_CAPTION, 'Press a key to close window')) backend.video_queue.put( backend.Event(backend.VIDEO_SHOW_CURSOR, False)) state.console_state.keyb.pause = True # this performs a blocking keystroke read if in pause state backend.check_events() except error.Reset: do_reset = True except KeyboardInterrupt: if config.get('debug'): raise except Exception as e: exit_error = "Unhandled exception\n%s" % traceback.format_exc() finally: try: audio.close() except (NameError, AttributeError) as e: logging.debug('Error on closing audio: %s', e) try: # fix the terminal on exit (important for ANSI terminals) # and save display interface state into screen state state.console_state.screen.close() except (NameError, AttributeError) as e: logging.debug('Error on closing screen: %s', e) # delete state if resetting if do_reset: state.delete() if plat.system == 'Android': shutil.rmtree(plat.temp_dir) else: state.save() try: # close files if we opened any devices.close_files() except (NameError, AttributeError) as e: logging.debug('Error on closing files: %s', e) try: devices.close_devices() except (NameError, AttributeError) as e: logging.debug('Error on closing devices: %s', e) if exit_error: logging.error(exit_error)
def start_basic(): """ Load & run programs and commands and hand over to interactive mode. """ import program import run import error import state import devices import disk import cassette import reset import sound import audio do_reset = False backend, console = None, None exit_error = '' try: # resume from saved emulator state if requested and available resume = config.get('resume') and state.load() # choose the video and sound backends backend, console = prepare_console() # greet, load and run only if not resuming if resume: # override selected settings from command line cassette.override() disk.override() # suppress double prompt if not state.basic_state.execute_mode: state.basic_state.prompt = False run.start('', False, config.get('quit')) else: # load/run program config.options['run'] = config.get(1) or config.get('run') prog = config.get('run') or config.get('load') if prog: # on load, accept capitalised versions and default extension with open_native_or_dos_filename(prog) as progfile: program.load(progfile) reset.clear() print_greeting(console) # start the interpreter (and get out if we ran with -q) run.start(config.get('exec'), config.get('run'), config.get('quit')) except error.RunError as e: exit_error = error.get_message(e.err) except error.Exit: # pause before exit if requested if config.get('wait'): backend.video_queue.put(backend.Event(backend.VIDEO_SET_CAPTION, 'Press a key to close window')) backend.video_queue.put(backend.Event(backend.VIDEO_SHOW_CURSOR, False)) state.console_state.keyb.pause = True # this performs a blocking keystroke read if in pause state backend.check_events() except error.Reset: do_reset = True except KeyboardInterrupt: if config.get('debug'): raise except Exception as e: print traceback.print_exc() exit_error = "Unhandled exception\n%s" % traceback.format_exc() finally: try: audio.close() except (NameError, AttributeError) as e: logging.debug('Error on closing audio: %s', e) try: # fix the terminal on exit (important for ANSI terminals) # and save display interface state into screen state state.console_state.screen.close() except (NameError, AttributeError) as e: logging.debug('Error on closing screen: %s', e) # delete state if resetting if do_reset: state.delete() if plat.system == 'Android': shutil.rmtree(plat.temp_dir) else: state.save() try: # close files if we opened any devices.close_files() except (NameError, AttributeError) as e: logging.debug('Error on closing files: %s', e) try: devices.close_devices() except (NameError, AttributeError) as e: logging.debug('Error on closing devices: %s', e) if exit_error: logging.error(exit_error)
def run(train, y, test, v, z): #cname = sys._getframe().f_code.co_name cname = 'p' train.drop('id', axis=1, inplace=True) test.drop('id', axis=1, inplace=True) from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=50, nfold=10, seed=params['seed']) score = cv.ix[len(cv) - 1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict(max_depth=hp.choice('max_depth', range(2, 9)), subsample=hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree=hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate=hp.quniform('learning_rate', 0.005, 0.1, 0.005), min_child_weight=hp.quniform('min_child_weight', 1, 6, 1), gamma=hp.quniform('gamma', 0.5, 10, 0.05), reg_alpha=hp.quniform('reg_alpha', 0, 1, 0.001), objective='binary:logistic', eval_metric='logloss', seed=1, silent=1) trs = state.load('xgb_trials') if trs == None or debug_mode: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:' % (len(tr.trials)), space_eval(space_xgb, tr.argmin)) best = tr.argmin while len(tr.trials) < 15: best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials=tr) state.save('xgb_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) N_splits = 9 N_seeds = 3 skf = model_selection.StratifiedKFold(n_splits=N_splits, shuffle=True) dtest = xgb.DMatrix(test) cv = [] for s in range(N_seeds): scores = [] cname2 = cname + str(s) v[cname2], z[cname2] = 0, 0 xgb_params['seed'] = s + 4242 for n, (itrain, ival) in enumerate(skf.split(train, y)): dtrain = xgb.DMatrix(train.ix[itrain], y[itrain]) dvalid = xgb.DMatrix(train.ix[ival], y[ival]) watch = [(dtrain, 'train'), (dvalid, 'valid')] clf = xgb.train(xgb_params, dtrain, 10000, watch, early_stopping_rounds=100, verbose_eval=False) p = clf.predict(dvalid) v.loc[ival, cname2] += p score = metrics.log_loss(y[ival], p) z[cname2] += clf.predict(dtest) print( cname, 'seed %d step %d of %d: ' % (xgb_params['seed'], n + 1, skf.n_splits), score, state.now()) scores.append(score) z[cname2] /= N_splits cv.append(np.mean(scores)) print('seed %d loss: ' % (xgb_params['seed']), scores, np.mean(scores), np.std(scores)) z['y'] = z[cname2] print('cv:', cv, np.mean(cv), np.std(cv)) return cv, None
def run(train, y, test, v, z): np.random.seed(1) #cname = sys._getframe().f_code.co_name train = train.values test = test.values from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval space_stack = hp.choice('stacking by', [ dict( type = 'BayesianRidge' ), dict( type = 'Lars' ), dict( type = 'LinearRegression' ), dict( type = 'Ridge' ), dict( type = 'SGDRegressor', random_state = 1 ), dict( type = 'XGBRegressor', max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0, 10, 0.05), reg_alpha = hp.quniform('alpha', 0, 1, 0.0001), ), ]) def get_lr(params): t = params['type'] del params['type'] if t == 'BayesianRidge': lr = linear_model.BayesianRidge(**params) elif t == 'Lars': lr = linear_model.Lars(**params) elif t == 'LinearRegression': lr = linear_model.LinearRegression(**params) elif t == 'Ridge': lr = linear_model.Ridge(**params) elif t == 'SGDRegressor': lr = linear_model.SGDRegressor(**params) elif t == 'XGBRegressor': lr = xgb.XGBRegressor(**params) return lr def step(params): print(params, end = ' ') cv = model_selection.cross_val_score(get_lr(params), train, y, cv=10, scoring=metrics.make_scorer(metrics.log_loss)) score = np.mean(cv) print(score) return dict(loss=score, status=STATUS_OK) trs = state.load('trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: best = tr.argmin print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_stack, best)) mt = max(50, len(tr.trials) + 1) while len(tr.trials) < min(50, mt): best = fmin(step, space_stack, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) state.save('trials', (tr, space_stack)) params = space_eval(space_stack, best) print('best params:', params) lr = get_lr(params) cv = model_selection.cross_val_score(lr, train, y, cv=10, scoring=metrics.make_scorer(metrics.log_loss)) lr.fit(train, y) z['p'] = np.clip(lr.predict(test), 1e-5, 1-1e-5) z['y'] = z['p'] v['p'] = model_selection.cross_val_predict(lr, train, y, cv=10) print('cv:', np.mean(cv), np.std(cv)) return cv, None
def start_basic(): """ Load & run programs and commands and hand over to interactive mode. """ import program import run import error import state import devices import disk import cassette import reset import sound do_reset = False backend, console = None, None try: # resume from saved emulator state if requested and available resume = config.get('resume') and state.load() # choose the video and sound backends backend, console = prepare_console() # greet, load and run only if not resuming if resume: # override selected settings from command line cassette.override() disk.override() # suppress double prompt if not state.basic_state.execute_mode: state.basic_state.prompt = False run.start('', False, config.get('quit')) else: # load/run program config.options['run'] = config.get(0) or config.get('run') prog = config.get('run') or config.get('load') if prog: # on load, accept capitalised versions and default extension with open_native_or_dos_filename(prog) as progfile: program.load(progfile) reset.clear() print_greeting(console) # start the interpreter (and get out if we ran with -q) run.start(config.get('exec'), config.get('run'), config.get('quit')) except error.RunError as e: msg = error.get_message(e.err) if console and config.get('wait'): console.write_error_message(msg, None) if backend and backend.video: # close terminal to avoid garbled error message backend.video.close() backend.video = None logging.error(msg) except error.Exit: pass except error.Reset: do_reset = True except KeyboardInterrupt: if config.get('debug'): raise except Exception as e: logging.error("Unhandled exception\n%s", traceback.format_exc()) finally: try: # fix the terminal on exit (important for ANSI terminals) # and save display interface state into screen state state.console_state.screen.close() except (NameError, AttributeError) as e: logging.debug('Error on closing screen: %s', e) # delete state if resetting if do_reset: state.delete() if plat.system == 'Android': shutil.rmtree(plat.temp_dir) else: state.save() try: # close files if we opened any devices.close_files() except (NameError, AttributeError) as e: logging.debug('Error on closing files: %s', e) try: devices.close_devices() except (NameError, AttributeError) as e: logging.debug('Error on closing devices: %s', e) try: sound.audio.close() except (NameError, AttributeError) as e: logging.debug('Error on closing audio: %s', e)
logging.info(myyaml.dump(common.dump.vars_seq([hyperparameters, miscglobals]))) #validate(0) diagnostics.diagnostics(cnt, m) # diagnostics.visualizedebug(cnt, m, rundir) while 1: logging.info("STARTING EPOCH #%d" % epoch) for ebatch in get_train_minibatch: cnt += len(ebatch) # print [wordmap.str(id) for id in e] noise_sequences, weights = corrupt.corrupt_examples(m, ebatch) m.train(ebatch, noise_sequences, weights) #validate(cnt) if cnt % (int(1000./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: logging.info("Finished training step %d (epoch %d)" % (cnt, epoch)) # print ("Finished training step %d (epoch %d)" % (cnt, epoch)) if cnt % (int(100000./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: diagnostics.diagnostics(cnt, m) if os.path.exists(os.path.join(rundir, "BAD")): logging.info("Detected file: %s\nSTOPPING" % os.path.join(rundir, "BAD")) sys.stderr.write("Detected file: %s\nSTOPPING\n" % os.path.join(rundir, "BAD")) sys.exit(0) if cnt % (int(HYPERPARAMETERS["VALIDATE_EVERY"]*1./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: state.save(m, cnt, epoch, get_train_minibatch, rundir, newkeystr) diagnostics.visualizedebug(cnt, m, rundir, newkeystr) # validate(cnt) get_train_minibatch = examples.TrainingMinibatchStream() epoch += 1
def run(state, train, y, test, v, z): #cname = sys._getframe().f_code.co_name cname = 'p' train.drop('id', axis=1, inplace=True) test.drop('id', axis=1, inplace=True) from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval def step_rf(params): clf = ensemble.RandomForestRegressor(**params) cv = model_selection.cross_val_score(clf, train, y, scoring=metrics.make_scorer(metrics.log_loss), cv = 10, n_jobs = -2) score = np.mean(cv) print(cname, score, params) return dict(loss=score, status=STATUS_OK) space_rf = dict( n_estimators = hp.choice('n_estimators', range(50, 1500)), #criterion = hp.choice('criterion', ["gini", "entropy"]), min_samples_split = hp.choice('min_samples_split', range(2, 10)), min_samples_leaf = hp.choice('min_samples_leaf', range(1, 10)), max_features = hp.choice('max_features', range(1, 16)), random_state = 1 ) trs = state.load('rf_trials') if trs == None or debug_mode: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_rf, tr.argmin)) best = tr.argmin while len(tr.trials) < 15: best = fmin(step_rf, space_rf, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) state.save('et_trials', (tr, space_rf)) rf_params = space_eval(space_rf, best) print(rf_params) N_splits = 9 N_seeds = 3 skf = model_selection.StratifiedKFold(n_splits=N_splits, shuffle=True) cv = [] for s in range(N_seeds): scores = [] cname2 = cname + str(s) v[cname2], z[cname2] = 0, 0 rf_params['random_state'] = s + 4242 for n, (itrain, ival) in enumerate(skf.split(train, y)): clf = ensemble.RandomForestRegressor(**rf_params) clf.fit(train.ix[itrain], y[itrain]) p = clf.predict(train.ix[ival]) v.loc[ival, cname2] += p score = metrics.log_loss(y[ival], p) z[cname2] += clf.predict(test) print(cname, 'seed %d step %d of %d: '%(rf_params['random_state'], n+1, skf.n_splits), score, state.now()) scores.append(score) z[cname2] /= N_splits cv.append(np.mean(scores)) print('seed %d loss: '%(rf_params['random_state']), scores, np.mean(scores), np.std(scores)) z['y'] = z[cname2] print('cv:', cv, np.mean(cv), np.std(cv)) return cv, None
bh -= gbh * LR w2 -= gw2 * LR b2 -= gb2 * LR # o = graph.validatefn(x, N.array([y]), w1, b1, w2, b2) # (kl, softmax, argmax, presquashh) = o ## print "new KL=%.3f, softmax=%s, argmax=%d" % (kl, softmax, argmax) # print "new KL=%.3f, argmax=%d" % (kl, argmax) if cnt % HYPERPARAMETERS["examples per validation"] == 0: valacc, valstd = validate() sys.stderr.write("After %d training examples, validation accuracy: %.2f%%, stddev: %.2f%% (former best=%.2f%% at %d)\n" % (cnt, valacc*100, valstd*100, best_validation_accuracy*100, best_validation_at)) if best_validation_accuracy < valacc: best_validation_accuracy = valacc best_validation_at = cnt sys.stderr.write("NEW BEST VALIDATION ACCURACY. Saving state.\n") if HLAYERS == 2: state.save((w1, b1, wh, bh, w2, b2), rundir, best_validation_accuracy, best_validation_at) else: state.save((w1, b1, w2, b2), rundir, best_validation_accuracy, best_validation_at) elif cnt > 2*best_validation_at and cnt >= HYPERPARAMETERS["minimum training updates"]: sys.stderr.write("Have not beaten best validation accuracy for a while. Terminating training...\n") sys.stderr.write(stats() + "\n") break if cnt % 1000 == 0: sys.stderr.write("After %d training examples, training accuracy %s\n" % (cnt, mvgavg_accuracy)) sys.stderr.write("After %d training examples, training loss %s\n" % (cnt, mvgavg_loss)) sys.stderr.write(stats() + "\n") #graph.COMPILE_MODE.print_summary()
def run(train, y, test, v, z): np.random.seed(1) #cname = sys._getframe().f_code.co_name train = train.values test = test.values from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval space_stack = hp.choice('stacking by', [ dict(type='BayesianRidge'), dict(type='Lars'), dict(type='LinearRegression'), dict(type='Ridge'), dict(type='SGDRegressor', random_state=1), dict( type='XGBRegressor', max_depth=hp.choice('max_depth', range(2, 8)), subsample=hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree=hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate=hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight=hp.quniform('min_child_weight', 1, 6, 1), gamma=hp.quniform('gamma', 0, 10, 0.05), reg_alpha=hp.quniform('alpha', 0, 1, 0.0001), ), ]) def get_lr(params): t = params['type'] del params['type'] if t == 'BayesianRidge': lr = linear_model.BayesianRidge(**params) elif t == 'Lars': lr = linear_model.Lars(**params) elif t == 'LinearRegression': lr = linear_model.LinearRegression(**params) elif t == 'Ridge': lr = linear_model.Ridge(**params) elif t == 'SGDRegressor': lr = linear_model.SGDRegressor(**params) elif t == 'XGBRegressor': lr = xgb.XGBRegressor(**params) return lr def step(params): print(params, end=' ') cv = model_selection.cross_val_score(get_lr(params), train, y, cv=10, scoring=metrics.make_scorer( metrics.log_loss)) score = np.mean(cv) print(score) return dict(loss=score, status=STATUS_OK) trs = state.load('trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: best = tr.argmin print('reusing %d trials, best was:' % (len(tr.trials)), space_eval(space_stack, best)) mt = max(50, len(tr.trials) + 1) while len(tr.trials) < min(50, mt): best = fmin(step, space_stack, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials=tr) state.save('trials', (tr, space_stack)) params = space_eval(space_stack, best) print('best params:', params) lr = get_lr(params) cv = model_selection.cross_val_score(lr, train, y, cv=10, scoring=metrics.make_scorer( metrics.log_loss)) lr.fit(train, y) z['p'] = np.clip(lr.predict(test), 1e-5, 1 - 1e-5) z['y'] = z['p'] v['p'] = model_selection.cross_val_predict(lr, train, y, cv=10) print('cv:', np.mean(cv), np.std(cv)) return cv, None
aux__ = string_helpers.string_used_words(used_letters) print("LETRAS YA USADAS: {}".format(aux__)) print(grafico.draw_sprite(lives, graphic_word)) if lives > 0: print("Quedan {} lives!!".format(lives)) else: ## si perdiste print("Que en paz descanse...") print("La palabra era... \"{}\"".format(hidden_word)) if score > 0 : print("Tienes un total de {} puntos".format(score)) _continue = input("Tu puntaje es {}! \n Sigues jugando? (y = SI / n = NO)".format(score)) if _continue == "n": ## Al ingresar 'y' va a emplezar de nuevo play = False to_save = state.save(score) with open(score_file, "r") as f: for line in f: to_save += line #convertir esto en print tabla con valores de mayor a menor print(to_save) with open(score_file, "w") as f: f.write(to_save)
def run(train, y, test, v, z): #cname = sys._getframe().f_code.co_name cname = 'p' train.drop('id', axis=1, inplace=True) test.drop('id', axis=1, inplace=True) from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=50, nfold=10, seed=params['seed']) score = cv.ix[len(cv)-1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict( max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0.5, 10, 0.05), objective = 'binary:logistic', eval_metric = 'logloss', seed = 1, silent = 1 ) trs = state.load('xgb_trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_xgb, tr.argmin)) best = tr.argmin while len(tr.trials) < 15: best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) state.save('xgb_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) N_splits = 9 N_seeds = 1 skf = model_selection.StratifiedKFold(n_splits=N_splits, shuffle=True) dtest = xgb.DMatrix(test) for s in range(N_seeds): scores = [] cname2 = cname + str(s) v[cname2], z[cname2] = 0, 0 xgb_params['seed'] = s + 4242 for n, (itrain, ival) in enumerate(skf.split(train, y)): dtrain = xgb.DMatrix(train.ix[itrain], y[itrain]) dvalid = xgb.DMatrix(train.ix[ival], y[ival]) watch = [(dtrain, 'train'), (dvalid, 'valid')] clf = xgb.train(xgb_params, dtrain, 10000, watch, early_stopping_rounds=100, verbose_eval=False) p = clf.predict(dvalid) v.loc[ival, cname2] += p score = metrics.log_loss(y[ival], p) z[cname2] += clf.predict(dtest) print(cname, 'seed %d step %d of %d: '%(xgb_params['seed'], n+1, skf.n_splits), score, state.now()) scores.append(score) z[cname2] /= N_splits cv = scores z['y'] = z[cname2] print('validation loss: ', cv, np.mean(cv), np.std(cv)) return cv, None
# The following is code for training on bilingual examples. # TODO: Monolingual examples? correct_sequences, noise_sequences, weights = ebatch_to_sequences(ebatch) translation_model[source_language].train(correct_sequences, noise_sequences, weights) #validate(translation_model, cnt) if int(cnt/1000) > int(lastcnt/1000): logging.info("Finished training step %d (epoch %d)" % (cnt, epoch)) # print ("Finished training step %d (epoch %d)" % (cnt, epoch)) if int(cnt/10000) > int(lastcnt/10000): for l1 in translation_model: diagnostics.diagnostics(cnt, translation_model[l1]) if os.path.exists(os.path.join(rundir, "BAD")): logging.info("Detected file: %s\nSTOPPING" % os.path.join(rundir, "BAD")) sys.stderr.write("Detected file: %s\nSTOPPING\n" % os.path.join(rundir, "BAD")) sys.exit(0) if int(cnt/HYPERPARAMETERS["VALIDATE_EVERY"]) > int(lastcnt/HYPERPARAMETERS["VALIDATE_EVERY"]): validate(translation_model, cnt) pass # for l1 in translation_model: # diagnostics.visualizedebug(cnt, translation_model[l1], rundir, newkeystr) validate(translation_model, cnt) # get_train_minibatch = w2w.examples.get_training_minibatch_online() get_train_minibatch = w2w.examples.get_training_minibatch_cached() epoch += 1 state.save(translation_model, cnt, lastcnt, epoch, rundir, newkeystr) # validate(cnt)
logging.info("INITIALIZING TRAINING STATE") logging.info(myyaml.dump(common.dump.vars_seq([hyperparameters, miscglobals]))) #validate(0) diagnostics.diagnostics(cnt, m) # diagnostics.visualizedebug(cnt, m, rundir) while 1: logging.info("STARTING EPOCH #%d" % epoch) for ebatch in get_train_minibatch: cnt += len(ebatch) # print [wordmap.str(id) for id in e] m.train(ebatch) #validate(cnt) if cnt % (int(1000./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: logging.info("Finished training step %d (epoch %d)" % (cnt, epoch)) # print ("Finished training step %d (epoch %d)" % (cnt, epoch)) if cnt % (int(100000./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: diagnostics.diagnostics(cnt, m) if os.path.exists(os.path.join(rundir, "BAD")): logging.info("Detected file: %s\nSTOPPING" % os.path.join(rundir, "BAD")) sys.stderr.write("Detected file: %s\nSTOPPING\n" % os.path.join(rundir, "BAD")) sys.exit(0) if cnt % (int(HYPERPARAMETERS["VALIDATE_EVERY"]*1./HYPERPARAMETERS["MINIBATCH SIZE"])*HYPERPARAMETERS["MINIBATCH SIZE"]) == 0: state.save(m, cnt, epoch, get_train_minibatch, rundir, newkeystr) diagnostics.visualizedebug(cnt, m, rundir, newkeystr) # validate(cnt) get_train_minibatch = examples.TrainingMinibatchStream() epoch += 1
def run(state, train, y, test, v, z): #cname = sys._getframe().f_code.co_name cname = 'p' train.drop('id', axis=1, inplace=True) test.drop('id', axis=1, inplace=True) from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval def step_et(params): clf = ensemble.ExtraTreesRegressor(**params) cv = model_selection.cross_val_score(clf, train, y, scoring=metrics.make_scorer( metrics.log_loss), cv=10, n_jobs=-2) score = np.mean(cv) print(cname, score, params) return dict(loss=score, status=STATUS_OK) space_et = dict( n_estimators=hp.choice('n_estimators', range(50, 1500)), #criterion = hp.choice('criterion', ["gini", "entropy"]), min_samples_split=hp.choice('min_samples_split', range(2, 10)), min_samples_leaf=hp.choice('min_samples_leaf', range(1, 10)), max_features=hp.choice('max_features', range(1, 16)), random_state=1) trs = state.load('et_trials') if trs == None or debug_mode: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:' % (len(tr.trials)), space_eval(space_et, tr.argmin)) best = tr.argmin while len(tr.trials) < 15: best = fmin(step_et, space_et, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials=tr) state.save('et_trials', (tr, space_et)) et_params = space_eval(space_et, best) print(et_params) N_splits = 9 N_seeds = 3 skf = model_selection.StratifiedKFold(n_splits=N_splits, shuffle=True) cv = [] for s in range(N_seeds): scores = [] cname2 = cname + str(s) v[cname2], z[cname2] = 0, 0 et_params['random_state'] = s + 4242 for n, (itrain, ival) in enumerate(skf.split(train, y)): clf = ensemble.ExtraTreesRegressor(**et_params) clf.fit(train.ix[itrain], y[itrain]) p = clf.predict(train.ix[ival]) v.loc[ival, cname2] += p score = metrics.log_loss(y[ival], p) z[cname2] += clf.predict(test) print( cname, 'seed %d step %d of %d: ' % (et_params['random_state'], n + 1, skf.n_splits), score, state.now()) scores.append(score) z[cname2] /= N_splits cv.append(np.mean(scores)) print('seed %d loss: ' % (et_params['random_state']), scores, np.mean(scores), np.std(scores)) z['y'] = z[cname2] print('cv:', cv, np.mean(cv), np.std(cv)) return cv, None
def think(dt, events, kpress, mpos): global alpha, playing, ending, lastsave if playing and not ending: alpha = min(2 * dt + alpha, 1) elif ending: alpha -= 2 * dt if alpha <= -6: hud.endtitle.settext() if not hud.endtitle: state.removesave() scene.pop() return else: alpha -= 2 * dt if alpha <= 0: scene.pop() return sound.setvolume(alpha) lastsave += dt if settings.savetime is not None and lastsave > settings.savetime: lastsave = 0 state.save() if kpress[K_ESCAPE]: state.save() scene.pop() scene.pop() playing = False dx = ((kpress[K_RIGHT]) - (kpress[K_LEFT])) * dt dy = ((kpress[K_UP]) - (kpress[K_DOWN])) * dt dr = ((kpress[K_e] or kpress[K_d]) - (kpress[K_a])) * dt dA = ((kpress[K_COMMA] or kpress[K_w]) - (kpress[K_o] or kpress[K_s])) * dt for event in events: if event.type == QUIT: state.save() scene.pop() scene.pop() playing = False if event.type == MOUSEBUTTONDOWN: if event.button == 4: camera.zoom /= 1.08 elif event.button == 5: camera.zoom *= 1.08 else: px, py = mpos if hud.click((px, settings.sy - py)): continue p = camera.screentoworld((settings.sx - px, settings.sy - py)) if p and cursor.tobuild: phat = p.norm() if state.canbuild(cursor.tobuild, phat) and not state.builderror(cursor.tobuild): f = camera.eye().rej(phat).norm() state.build(cursor.tobuild(p.norm(), f)) cursor.tobuild = None else: sound.play("error") elif cursor.pointingto: if cursor.unbuild: state.unbuild(cursor.pointingto) elif cursor.disable: state.toggleenable(cursor.pointingto) else: cursor.dragging = True if event.type == MOUSEBUTTONUP: cursor.dragging = False if event.type == MOUSEMOTION: relx, rely = event.rel if event.buttons[0]: dx -= relx * settings.dragfactor / settings.sy dy += rely * settings.dragfactor / settings.sy if event.buttons[2]: dr -= relx * settings.dragfactor / settings.sy dA += rely * settings.dragfactor / settings.sy # camera.seek((0, 0, 1)) if event.type == KEYDOWN and event.key == K_CAPSLOCK: settings.swaparrows = not settings.swaparrows if event.type == KEYDOWN and event.key == K_F3 and settings.unlocked >= 99: if settings.level == 3: scene.pushunder(scenes.final) ending = True hud.endtitle.settext("Mission Complete") if event.type == KEYDOWN and event.key == K_F12: graphics.screenshot() if event.type == KEYDOWN and event.key == K_INSERT: camera.zoom /= 1.2 if event.type == KEYDOWN and event.key == K_DELETE: camera.zoom *= 1.2 if event.type == KEYDOWN and event.key == K_SPACE: things.Asteroid(100) camera.zoom = min(max(camera.zoom, 30), 200) if bool(kpress[K_LSHIFT]) != bool(settings.swaparrows): dx, dy, dr, dA = dr, dA, dx, dy camera.move(40. * dx / state.R, 40. * dy / state.R, 2.5 * dr, 0.7 * dA) camera.think(dt) px, py = mpos hud.point((px, settings.sy - py)) dtobj = dt * settings.speedup for obj in state.thinkers(): obj.think(dtobj) hud.think(dt) state.think(dtobj) hud.setstatus() if not ending: if state.checklose(): ending = True hud.endtitle.settext("Mission Failed") elif state.checkwin(dt): if settings.level == 3: scene.pushunder(scenes.final) sound.play("success") ending = True hud.endtitle.settext("Mission Complete") settings.unlocked = max(settings.unlocked, settings.level + 1) settings.save()
def clickon(bname): soundname = buttons[bname].soundname if bname == "buildw": if mode == "main": buildwmode() elif mode == "buildw": soundname = "back" mainmode() elif bname == "buildb": if mode == "main": buildbmode() elif mode == "buildb": soundname = "back" mainmode() elif bname == "buildr": if mode == "main": buildrmode() elif mode == "buildr": soundname = "back" mainmode() elif bname.startswith("build"): cursor.tobuild = buttons[bname].btype if bname == "launch": if mode == "main": launchmode() elif mode == "launch": soundname = "back" mainmode() elif bname.startswith("launch"): if state.launcherror(buttons[bname].ltype): soundname = "error" else: state.launch(buttons[bname].ltype) soundname = "launch" if bname == "help": if mode == "main": soundname = "back" helpmode() elif mode == "help": mainmode() elif bname == "helpmission": labels["helppage"].settext(info.missionhelp[settings.level]) elif bname.startswith("help"): labels["helppage"].settext(info.help[buttons[bname].helpname]) if bname == "unbuild": if mode == "main": unbuildmode() elif mode == "unbuild": soundname = "back" mainmode() if bname == "unlaunch": if mode == "main": unlaunchmode() elif mode == "unlaunch": soundname = "back" mainmode() elif bname.startswith("unlaunch"): state.unlaunch(buttons[bname].ltype) if bname == "disable": if mode == "main": disablemode() elif mode == "disable": soundname = "back" mainmode() if bname == "back": soundname = "back" cursor.tobuild = None mainmode() if bname == "bcancel": soundname = "back" cursor.tobuild = None if bname == "quit": soundname = "back" quitmode() if bname == "abandonquit": soundname = "back" state.removesave() scene.top().playing = False if bname == "savequit": soundname = "back" state.save() scene.pop() scene.pop() if bname == "quitgame": scene.top().playing = False if bname.startswith("level"): scene.top().playing = False scene.top().selected = buttons[bname].n if bname == "selectlevel": if mode == "level": soundname = "back" menumode() else: levelmode() if bname == "options": if mode == "options": soundname = "back" menumode() else: optionsmode() if bname == "credits": if mode == "credits": soundname = "back" menumode() else: creditsmode() if bname == "soundtoggle": settings.sound = not settings.sound settings.save() sound.setvolume() if bname == "musictoggle": settings.music = not settings.music settings.save() sound.setvolume() if bname == "fullscreentoggle": settings.fullscreen = not settings.fullscreen settings.save() if bname == "wsizesmall": settings.wsize = 640, 360 settings.save() if bname == "wsizemedium": settings.wsize = 854, 480 settings.save() if bname == "wsizelarge": settings.wsize = 1280, 720 settings.save() if bname == "wsizevlarge": settings.wsize = 1920, 1080 settings.save() if mode == "options": buttons["soundtoggle"].words = "SOUND: %s" % ("ON" if settings.sound else "OFF") buttons["musictoggle"].words = "MUSIC: %s" % ("ON" if settings.music else "OFF") buttons["fullscreentoggle"].words = "FULLSCREEN: %s" % ("ON" if settings.fullscreen else "OFF") for sname in "small medium large vlarge".split(): b = buttons["wsize" + sname] size = map(int, b.words.split()[-1].split("x")) b.color = (180, 255, 180) if tuple(size) == tuple(settings.wsize) else (180, 180, 180) sound.play(soundname)