def final_save(self, model_name, save_dir): """ Print and save the best results Args: model_name: save_dir: directory for saving results """ if (self.save_precision is not None) and (self.save_recall is not None): tp.banner('This is the best results!') mean = (self.save_precision[100] + self.save_precision[200] + self.save_precision[300]) / 3 data = [[ self.save_precision[100], self.save_precision[200], self.save_precision[300], mean, self.best_auc, self.f1_score ]] headers = ['P@100', 'P@200', 'P@300', 'Mean', 'AUC', 'Max F1'] tp.table(data, headers) ensure_folder(save_dir) np.save(os.path.join(save_dir, '{}_recall.npy'.format(model_name)), self.save_recall[:2000]) np.save( os.path.join(save_dir, '{}_precision.npy'.format(model_name)), self.save_precision[:2000]) else: logger.error('No model result to save')
def __printTable__(title, data, headers): tp.banner(title) columns_max_width = __calculateColumnsMaxWidth__(headers, data) tp.table(data=data, headers=headers, width=columns_max_width, style='fancy_grid')
def test_banner(): """Tests the banner function""" output = StringIO() banner('hello world', style='clean', width=11, out=output) assert output.getvalue() == ' ─────────── \n hello world \n ─────────── \n' output = StringIO() banner('!', style='banner', width=1, out=output) assert output.getvalue() == '╒═╕\n│!│\n╘═╛\n'
def main(action, search_query, ids, start, max_result, sort_by, sort_order, v, output): """A cli package for accessing and quering arxiv papers.""" if v: click.echo("Building query parameters \n") kwargs = { "start": start, "max_result": max_result, "sort_by": sort_by, "sort_order": sort_order, "search_query": search_query, "ids": ids } print(kwargs) if v: click.echo("Parameters built \n") if action == "query": arxiv = Arxiv(**kwargs) text = """The provided query parameters are {0} .\nThe request url is {1} \n""".format( arxiv.query_url_args, arxiv.request_url) if v: click.echo(text) query_result = arxiv.query() if v: click.echo("Query Complete \n{} result \n".format( "Printing raw as list" if output == "list" else "Printing raw as json" if output == "json" else "Tabulating")) if output == "list": print(query_result) elif output == "json": import json output = json.dumps(query_result) print(output) else: click.echo( "Tabulating is currently not supported. It should be by tomorrow. Rolling back to pprint" ) pprint.pprint(query_result) if action == "download": arxiv = Arxiv(**kwargs) text = """The provided query parameters are {0} .\nThe request url is {1} \n""".format( arxiv.query_url_args, arxiv.request_url) if v: click.echo(text) arxiv_query = arxiv.query()[0] if v: click.echo("Query Complete\n") if v: click.echo("Downloading Paper\n") arxiv.download(arxiv_query) tableprint.banner("Successfully Downloaded Paper : {0}".format( arxiv_query['title'])) if action == "get_paper": arxiv = Arxiv(**kwargs) arxiv_query = arxiv.query()[0] pprint.pprint(arxiv_query)
def ANTCOL(G, ncycles, nants, alpha, beta, rho, k): """ Procedimiento principal para la metaheurística descrita en el artículo. :param G: networkx.Graph :param ncycles: El número de ciclos total de ejecución. :param nants: El número de hormigas que se usarán. :params alpha beta: Los metaparámetros para la obtención de la probabilidad de elección de los vértices para su coloración. :param rho: Metaparámetro para la evaporación. :param k: El número de particiones existentes en la gráfica sobre la que se trabajará. Servirá potencialmente para hacer optimizaciones. :return: La lista de clases de colores que se obtuvieron para la coloración de G. :rtype: [ColorClass]. """ tp.banner("Lista de Vértices V: ") V = list(G) print(V) tp.banner("Lista de aristas E: ") E = list(G.edges) print(E) t = initialise_trail_matrix(V) # Inicializar matriz de rastros. list_color_classes = [] for cycle in range(1, ncycles + 1): print("> ciclo:", cycle) delta = initialise_trail_update_matrix( t) # Inicializar matriz de actualización de rastros. for ant in range(1, nants + 1): print("\t-- hormiga:", ant) X = V # Inicializar la lista de vértices no coloreados. k = 0 # Inicializar el número de colores usados. while X: k = k + 1 C_k = ColorClass(k) # Inicializar la clase de color k. list_color_classes.append(C_k) F = X # Inicializar la lista de vértices aún factibles para colorear con k. i = select_with_probability( F, 1 / len(F)) # Seleccionar i ∈ F con probabilidad 1/|F|. COLOUR_VERTEX(G, i, k, list_color_classes, F, X) while F: i = select_pik(G, list_color_classes, alpha, beta, t, F) COLOUR_VERTEX(G, i, k, list_color_classes, F, X) update_trail_update_matrix( G, delta, k) # Actualizar matriz de actualización de rastros. update_trail_matrix(G, t, delta, rho) # Actualizar matriz de rastros. return list_color_classes # Regresar las clases de color.
def main(): check_schema_migration() tableprint.banner("Easier Life! Easier Work!") context = Context() while True: try: process_input(context) except KeyboardInterrupt: continue except EOFError: break print('GoodBye!')
def disp_results(results,imp=False) : results, impurities = results[0], results[1] yx=[] for molecule in results.molecules : yx.append((molecule.name,molecule.mass,molecule.charge,molecule.probability)) tp.banner('Combinaison results') tp.table(yx,['Combinaison','DA','Charge','Probability'], style='fancy_grid', width=25) if imp!=False : yx = [] for molecule in impurities.molecules: yx.append((molecule.name, molecule.mass, molecule.charge, molecule.probability)) tp.banner('Impurities') tp.table(yx, ['Combinaison', 'DA', 'Charge', 'Relative Probability'], style='fancy_grid', width=25)
def fit_ln(expt, ci, stim, activation, l2_reg=0.1): if activation.lower() == 'rbf': model_args = (30, 6) else: model_args = () model = functools.partial(linear_nonlinear, activation=activation, l2_reg=l2_reg) tp.banner( f'Training LN-{activation}, expt {args.expt}, {args.stim}, cell {ci+1:02d}' ) train(model, expt, stim, model_args=model_args, lr=1e-2, nb_epochs=500, val_split=0.05, cells=[ci])
def write_to_screen(self): """ The key method to this class prints the data frame in a nice manner which scales to the terminal size available to the user. """ screen_width, widths, modified_data_frame = self.fit_screen() tp.banner( self.config.banner, width=screen_width, ) if self.data_frame.empty: tp.banner( self.config.empty_banner, width=screen_width, ) return tp.dataframe(modified_data_frame, width=widths)
def disp_select(results,DA) : results, impurities = results[0], results[1] yx=[] total=0 for molecule in results.molecules : if molecule.mass == DA : yx.append([molecule.name,molecule.charge,molecule.probability]) total+=molecule.probability for molecule in yx : molecule.append(molecule[-1]/total*100) tp.banner('DA Probability Results for %s' % DA) tp.table(yx,['Combinaison','Charge','Overall Probability','DA Probability (%)'], style='fancy_grid', width=25) yx=[] for molecule in impurities.molecules : if molecule.mass == DA : yx.append([molecule.name,molecule.charge,molecule.probability]) total+=molecule.probability for molecule in yx : molecule.append(molecule[-1]/total*100) tp.banner('Impurities at %s' % DA) tp.table(yx,['Combinaison','Charge','Relative Probability','DA Probability (%)'], style='fancy_grid', width=25)
def message(self, msg): #print(msg['type']) if(str(msg['type']) =='chat'): if(len(msg['body'])>3000): tp.banner('<-------IMAGEN RECIBIDA------->') received = msg['body'].encode('utf-8') received = base64.decodebytes(received) #save the imagen in dir with open("images/imagen.jpg", "wb") as file_path: file_path.write(received) # open de image, en another windows with Image.open('images/imagen.jpg') as img: img.show() print('Siga escogiendo una opcion: ') else: tp.banner('<-------NUEVO MENSAJE PRIVADO RECIBIDO------->') print('De: %s' % str(msg['from']).split('@')[0]) print('Mensaje: %s ' % msg['body']) print('Siga escogiendo una opcion:') # message group elif(str(msg['type']) =='groupchat'): tp.banner('<-------MENSAJE EN LA SALA %s------->' % str(msg['from']).split('@')[0]) #print(msg['from][0]) print('De: %s' % str(msg['from']).split('@')[0]) print('Mensaje: %s ' % msg['body']) print('Siga escogiendo una opcion:')
def summary(self): # 打印整个sample的规则 headers = ['Parameter', 'Value'] content = [['unit', self.get_unit()], ['tmin', self.get_tmin()], ['tmax', self.get_tmax()], ['n_splits', self.get_n_splits()], ['test_size', self.get_test_size()], ['class_balance', 'True' if self.get_class_balance() else 'False'], ['data_balance', 'True' if self.get_data_balance() else 'False'], ['epoch_padding', 'True' if self.epoch_padding else 'False'], ['data_padding', 'True' if self.data_padding else 'False'], ['max_len', self.max_len if self.max_len is not None else 'Not Set'], ['x', str(self.get_x())], ['y', str(self.get_y())], ['Sample Mode', self.mode if hasattr(self, 'mode') else 'Not Set']] tp.banner('Your Sampling Settings') tp.table(content, headers)
:param G: networkx.Graph :param t: Matriz de rastros. :param delta: Matriz de actualización de la matriz de rastros. :param rho: Metaparámetro para la evaporación de los rastros (feromonas). """ for i in range(len(G.nodes)): for j in range(len(G.nodes)): if i != j: t[i][j] = (rho * t[i][j]) + delta[i][j] if __name__ == '__main__': # Inicio y pidiendo máximo número de vértices al usuario. tp.banner("Algoritmo ANTCOL (Algoritmo ACO de Dowsland y Thompson).") num_vertices = int(input("Máximo número de vértices (recomiendo 30): ")) # Contrucción de la gráfica k-partita y dibujándola. print( "> Contruyendo gráfica aleatoria k-partita que sabemos es k-coloreable..." ) G, k = create_k_partite(num_vertices) print( "\n> Mostrando la gráfica generada (cerrar el plot para continuar)...") plt.figure() title = "Gráfica G original, " + str(k) + "-partita" plt.title(title, color='blue') nx.draw(G, node_color='black', with_labels=True,
expt, stim, model_args=model_args, lr=1e-2, nb_epochs=500, val_split=0.05, cells=[ci]) if __name__ == '__main__': os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # expts = ('15-10-07', '15-11-21a', '15-11-21b') # stims = ('whitenoise', 'naturalscene') parser = argparse.ArgumentParser(description='Train a BN_CNN model') parser.add_argument('--expt', help='Experiment date (e.g. 15-10-07)') parser.add_argument('--stim', help='Stimulus class (e.g. naturalscene)') parser.add_argument('--model', help='Model architecture (e.g. BN_CNN or LN_softplus)') parser.add_argument('--cell', help='Cell index (only for LN models)') args = parser.parse_args() if args.model.upper() == 'BN_CNN': tp.banner(f'Training BN_CNN, expt {args.expt}, {args.stim}') fit_bn_cnn(args.expt, args.stim) elif args.model.split('_')[0].upper() == 'LN': activation = args.model.split('_')[1] fit_ln(args.expt, int(args.cell), args.stim, activation)
#print('modelo_simulacion\Scripts\activate.bat') # variables para modelar la simulacion dentro de graficas wait_time = [] wait_time_attend = [] cliente_served = [] enviroment = simpy.Environment() number_cajas = input('Ingrese el numero de las cajas: ') number_cajas = int(number_cajas) cajas = [ Cajero(enviroment, number) for number in range(1, number_cajas + 1) ] enviroment.process(Cliente.setup(enviroment, cajas)) enviroment.run(until=500 * 2) #recoremos la cajas for caja in cajas: cliente_served.append(caja.client_served) number = caja.numeros_cajero tp.banner(emoji.emojize(':money_bag: CAJA %d :money_bag:' % number)) # bug entre más cajero no encuentra el tiempo priomedio en la cola print('El tiempo promedio de un cliente en la cola: %d segundos' % (np.mean(caja.timeout))) print('Total de Clientes Atendidos: %d' % caja.client_served) print('Número de clientes en la cola: %d' % caja.cola) total = np.sum(cliente_served) grado = (caja.client_served / total) * 100 print('Grado de utilización de cada cajero %f:' % grado) print(emoji.emojize('Python is :money_bag:'))
def new_user_add(self, presence): tp.banner('TE HA AGREGADO EL USUARIO: %s' % str(presence['from']))
def on_epoch_begin(self, epoch, logs={}): tp.banner(f"Epoch {epoch}") print(tp.header(['iter', 'loss']))
def action_list(b_list): action = [''] for i in range(len(b_list) - 1): if b_list[i] == b_list[i + 1]: action.append('') else: if b_list[i + 1]: action.append('buy') else: action.append('sell') return (action) tableprint.banner('Exponential Moving Average Cross Over Strategy') PRICE_LIST = list_price(END_TIME) SHORT_EMA = ema_list(PRICE_LIST, SHORT) LONG_EMA = ema_list(PRICE_LIST, LONG) ACTION_LIST = action_list(action(PRICE_LIST, SHORT, LONG)) # Dictionaries ACCOUNT_A1 = {'USD': 1000.00, 'BTC': 0.0} BOOLEAN_ACTION = {True: 'buy', False: 'sell'} BOOLEAN_CURRENCY = {True: 'BTC', False: 'USD'} BOOLEAN_PRICE = {True: 1, False: -1} # Account Currency Currency Float Float -> Account # For a given account, currency to be sold, currency to be bought,
def fit(self, num_alt=2, max_iter=20, num_likelihood_steps=50, disp=2, check_grad=None, callback=None): """ Runs an optimization algorithm to learn the parameters of the model given training data and regularizers Parameters ---------- num_alt : int, optional The number of times to alternate between optimizing nonlinearities and optimizing filters. Default: 2 max_iter : int, optional The maximum number of steps to take during each leg of the alternating minimization. Default: 25 num_likelihood_steps : int, optional The number of steps to take when optimizing the data likelihood term (using SFO) disp : int, optional How much information to display during optimization. (Default: 2) check_grad : string, optional If 'f' or 'W', then the gradient of the log-likelihood objective with respect to that parameter is checked against a numerical estimate. callback : function A callback function that gets called each iteration with the current parameters and a dictionary of other information Notes ----- See the `proxalgs` module for more information on the optimization algorithm """ # grab the initial parameters theta_current = { 'W': self.theta_init['W'].copy(), 'f': self.theta_init['f'].copy() } # get list of training data train_data = [self.data[idx] for idx in self.indices['train']] # data generator def datagen(): while True: yield np.random.choice(train_data, 1)[0] # store train/test results during optimization self.convergence = defaultdict(list) def update_results(): if disp > 0: tmp_results = self.print_test_results(theta_current) for k in ('train', 'test'): self.convergence[k].append(tmp_results[k]) # runs the optimization procedure for one set of parameters (a single # leg of the alternating minimization) def optimize_param(f_df_wrapper, param_key, check_grad, cur_iter): # initialize the SFO instance loglikelihood_optimizer = SFO( f_df_wrapper, theta_current[param_key], train_data, display=0) # check gradient if check_grad == param_key: loglikelihood_optimizer.check_grad() # initialize the optimizer object opt = Optimizer('sfo', optimizer=loglikelihood_optimizer, num_steps=num_likelihood_steps) # add regularization terms [opt.add_regularizer(reg) for reg in self.regularizers[param_key]] # run the optimization procedure t0 = perf_counter() opt.minimize( theta_current[param_key], max_iter=max_iter, disp=disp, callback=callback) t1 = perf_counter() - t0 print('Finished optimizing ' + param_key + '. Elapsed time: ' + tp.humantime(t1)) return opt.theta # print results based on the initial parameters print('\n') tp.banner('Initial parameters') update_results() try: # alternating optimization: switch between optimizing nonlinearities, # and optimizing filters for alt_iter in range(num_alt): # Fit filters print('\n') tp.banner('Fitting filters') # wrapper for the objective and gradient def f_df_wrapper(W, d): return self.f_df(W, theta_current['f'], d, param_gradient='W') # run the optimization procedure for this parameter Wk = optimize_param(f_df_wrapper, 'W', check_grad, alt_iter + 0.5).copy() # normalize filters for filter_index in range(Wk.shape[0]): theta_current['W'][filter_index] = utilities.nrm(Wk[filter_index]) # print and save test results update_results() # Fit nonlinearity print('\n') tp.banner('Fitting nonlinearity') # wrapper for the objective and gradient def f_df_wrapper(f, d): return self.f_df(theta_current['W'], f, d, param_gradient='f') # run the optimization procedure for this parameter theta_current['f'] = optimize_param(f_df_wrapper, 'f', check_grad, alt_iter + 1).copy() # print and save test results update_results() except KeyboardInterrupt: print('\nCleaning up... ') # store learned parameters self.theta = copy.deepcopy(theta_current) print('Done.\n')
packet_list = [] packet_dic = {} with open("output.json") as json_file: data_dict = json.load(json_file) for x in range(0,len(data_dict)): if list(data_dict[x]['_source']['layers']['http'])[0] != '_ws.expert': request_method = list(data_dict[x]['_source']['layers']['http'])[0] else: request_method = list(data_dict[x]['_source']['layers']['http'])[1] packet_dic = {'No':'', 'requests':'', 'src':'', 'dst':'', 'host': '', 'blacklist_status':''} packet_dic['No'] = x packet_dic['requests'] = data_dict[x]['_source']['layers']['http'][request_method]['http.request.method'] packet_dic['src'] = data_dict[x]['_source']['layers']['ip']['ip.src'] packet_dic['dst'] = data_dict[x]['_source']['layers']['ip']['ip.dst'] packet_dic['host'] = data_dict[x]['_source']['layers']['http']['http.host'] packet_dic['blacklist_status'] = urlvoid.packet_check(packet_dic['host']) packet_list.append(packet_dic) time.sleep(0.9) headers = ['No', 'Requests', 'SRC', 'DST', 'HOST', 'Blacklist Status'] rows = [a.values() for a in packet_list] tableprint.banner('Malware Traffic Analysis With Python') tableprint.table(rows, headers)
data = data[data.send_bet_status.str.contains('Accepted')] del data['hilow_content'] # merge with result data = data.merge(result[['event_id', 'result_corner']], how='inner', on='event_id') data = data[~data.result_corner.isna()] data['result_corner'] = data['result_corner'].apply(pd.to_numeric) data['is_win'] = np.where(data.hilow == 'Low', np.where(data.line > data.result_corner, 1, 0), np.where(data.line < data.result_corner, 1, 0)) data['pnl'] = np.where(data.is_win == 1, data.odds - 1, -1) data['pnl_actual'] = data.bet_amount * data.pnl tp.banner("Bet Slips") # table = [] # cols = ['event_id','bet_amount','hilow','line','is_win','pnl','pnl_actual'] # bet_slip = data[cols].tail(40).values.tolist() # tp.table(bet_slip, cols) print( "───────────────────────────────────────────────────────────────────────") print(data[[ 'event_id', 'bet_amount', 'hilow', 'line', 'is_win', 'pnl', 'pnl_actual' ]].tail(40)) sentence_1 = ' Current running profit/loss: $ {} for $ 1 in each bet '.format( round(data['pnl'].sum(), 2)) sentence_2 = ' Current running actual profit/loss: $ {} since starting stack '.format( round(data['pnl_actual'].sum(), 2)) tp.banner(sentence_1) tp.banner(sentence_2)
#print (os.path.dirname(thefile)) try: os.chdir(os.path.dirname(thefile)) except BaseException: os.chdir(rootdir) file_num += 1 count = count + numpages print('\n') ''' print('='*50) print('检查到 %s个文件共 '%file_num + str(count) + ' 页,其中:') #print('-'*50) print("\n") print(tabulate([["A4",a4,"--->",a4],["A3",a3,"--->",a3*2],["A2",a2,"--->",a2*4],["A1",a1,"--->",a1*8],["A0",a0,"--->",a0*16]],headers=["幅面","页数","","折合A4"],tablefmt='orgtbl')) #print('其中A4 %s页,A3 %s页, A2 %s页, A1 %s页, A0 %s页' % (a4, a3, a2, a1, a0)) #print('-'*50) print("\n") print('折算后总计: %s 页'%(a4+a3*2+a2*4+a1*8+a0*16)) print('-'*50) ''' tableprint.banner('检查到 %s 个文件共 ' % file_num + str(count) + ' 页', style='clean') header = ['幅面', '页数', '', '折合A4'] data = [["A4", a4, "--->", a4], ["A3", a3, "--->", a3 * 2], ["A2", a2, "--->", a2 * 4], ["A1", a1, "--->", a1 * 8], ["A0", a0, "--->", a0 * 16]] tableprint.table(data, header) tableprint.banner('图纸折算A4后总计 %s 页' % (a4 + a3 * 2 + a2 * 4 + a1 * 8 + a0 * 16), style='clean') input()
Escoga una opcion: ''' states = { '1': 'chat', '2': 'away', '3': 'xa', '4': 'dnd' } flag = True # Para mostrar el menu correspondiente login_check = False while flag: if not(login_check): tp.banner('Bienvenido al Server %s' % DOMAIN) opcion = input(menu_logging) else: tp.banner('<-------¿Que desea Realizar?------->') opcion = input(menu_interaction) if(opcion=='1'): if not login_check: tp.banner('<-------REGISTRO DE USUARIO------->') name = input('Ingrese el Nombre: ') username = input('Ingrese usuario: ') email = input('Ingrese email: ') password = input('Ingrese contraseña: ') jid = username + DOMAIN register = RegistrerUser(jid, password, name, email) if register.connect():
def banner(msg, style='banner'): print('\033[92m', end='') tp.banner(msg, width=60, style=style) print('\033[0m', end='')
def printOutput(output): tp.banner(output) logging.debug(output)
def train(model, experiment, monitor, num_epochs, augment=False): """Train the given network against the given data Parameters ---------- model : keras.models.Model or glms.GLM A GLM or Keras Model object experiment : experiments.Experiment An Experiment object monitor : io.Monitor Saves the model parameters and plots of performance progress num_epochs : int Number of epochs to train for reduce_lr_every : int How often to reduce the learning rate reduce_rate : float A fraction (constant) to multiply the learning rate by """ assert isinstance(model, (Model, GLM)), "'model' must be a GLM or Keras model" # initialize training iteration iteration = 0 train_start = time() # loop over epochs try: for epoch in range(num_epochs): tp.banner('Epoch #{} of {}'.format(epoch + 1, num_epochs)) print(tp.header(["Iteration", "Loss", "Runtime"]), flush=True) # loop over data batches for this epoch for X, y in experiment.train(shuffle=True): # update on save_every, assuming it is positive if (monitor is not None) and (iteration % monitor.save_every == 0): # performs validation, updates performance plots, saves results to dropbox monitor.save(epoch, iteration, X, y, model.predict) # train on the batch tstart = time() loss = model.train_on_batch({'stim':X, 'loss':y})[0] elapsed_time = time() - tstart # update iteration += 1 print(tp.row([iteration, float(loss), tp.humantime(elapsed_time)]), flush=True) print(tp.bottom(3)) except KeyboardInterrupt: print('\nCleaning up') # allows the monitor to perform any post-training visualization if monitor is not None: elapsed_time = time() - train_start monitor.cleanup(iteration, elapsed_time) tp.banner('Training complete!')
def fit_glm(ci, exptdate, stimulus, cutout=7, history=40): tp.banner(f'Training GLM, expt {exptdate}, {stimulus}, cell {ci+1:02d}') # load experiment expt = experiments.loadexpt(exptdate, (ci, ), stimulus, 'train', history, 5000, cutout_width=cutout) tf.reset_default_graph() stim = tf.placeholder(tf.float32, shape=(None, *expt.X.shape[1:]), name='stimulus') hist = tf.placeholder(tf.float32, shape=(None, *expt.spkhist.shape[1:]), name='spike_history') rate = tf.placeholder(tf.float32, (None, 1), name='firing_rate') graph = Graph(stim, hist, rate) # define model model = GLM(l2_filter=1e-4, l2_hist=1e-2) pred = model(stim, hist) # neg. log-likelihood loss epsilon = 1e-6 dt = 1e-2 loss = dt * tf.reduce_mean(pred - rate * tf.log(pred + epsilon)) # training opt = tf.train.AdamOptimizer(learning_rate=1e-3) regs = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) reg_total = tf.reduce_sum(regs) train_op = opt.minimize(loss + reg_total) sess = tf.Session() sess.run(tf.global_variables_initializer()) metrics = { 'loss': loss, 'filter_norm': tf.nn.l2_loss(model.get_variables()[0]), 'hist_norm': tf.nn.l2_loss(model.get_variables()[1]), 'reg_total': reg_total, 'cc': tf.squeeze(cc(pred, rate)), 'fev': tf.squeeze(fev(pred, rate)), 'rmse': tf.squeeze(rmse(pred, rate)), } for reg in regs: if 'spike_history' in reg.name: if 'w' in reg.name: metrics['l2_hist'] = reg else: metrics['l2_offset'] = reg if 'filter' in reg.name: metrics['l2_filter'] = reg store = defaultdict(list) feed = datafeed(expt, graph, niter=1000) for fd in tqdm(feed): res = sess.run([train_op, metrics], feed_dict=fd)[1] for k, v in res.items(): store[k].append(v) # get parameters weights, whist, offset = sess.run(model.get_variables()) sta = weights.reshape(history, cutout * 2, cutout * 2) whist = whist.ravel() testdata = experiments.loadexpt(exptdate, (ci, ), stimulus, 'test', history, 5000, cutout_width=cutout) test_feed = next(datafeed(testdata, graph, batchsize=None)) test_pred = sess.run(pred, feed_dict=test_feed)[:, 0] test_rate = testdata.y # test metrics test = { 'cc': np_wrap(cc)(test_rate, test_pred), 'rmse': np_wrap(rmse)(test_rate, test_pred), 'fev': np_wrap(fev)(test_rate, test_pred), } # save results = { 'stimulus_filter': sta, 'history_filter': whist, 'bias': offset, 'test_scores': test, 'train_store': dict(store), 'test_pred': test_pred, 'test_rate': test_rate, } basedir = os.path.expanduser('~/research/deep-retina/results/glms/') folder = os.path.join(basedir, f'{exptdate}_{stimulus}') try: os.mkdir(folder) except FileExistsError: pass dd.io.save(os.path.join(folder, f'cell{ci:02d}.h5'), results)