def output_and_loss(self, h_block, t_block): batch, units, length = h_block.shape # shape : (batch * sequence_length, num_classes) logits_flat = seq_func(self.affine, h_block, reconstruct_shape=False) rebatch, _ = logits_flat.shape concat_t_block = t_block.view(rebatch) weights = (concat_t_block >= 1).float() n_correct, n_total = utils.accuracy(logits_flat, concat_t_block, ignore_index=0) # shape : (batch * sequence_length, num_classes) log_probs_flat = F.log_softmax(logits_flat, dim=-1) # shape : (batch * max_len, 1) targets_flat = t_block.view(-1, 1).long() if self.label_smoothing is not None and self.label_smoothing > 0.0: num_classes = logits_flat.size(-1) smoothing_value = self.label_smoothing / (num_classes - 1) # Fill all the correct indices with 1 - smoothing value. one_hot_targets = input_like(log_probs_flat, smoothing_value) smoothed_targets = one_hot_targets.scatter_(-1, targets_flat, 1.0 - self.label_smoothing) negative_log_likelihood_flat = - log_probs_flat * smoothed_targets negative_log_likelihood_flat = negative_log_likelihood_flat.sum(-1, keepdim=True) else: # Contribution to the negative log likelihood only comes from the exact indices # of the targets, as the target distributions are one-hot. Here we use torch.gather # to extract the indices of the num_classes dimension which contribute to the loss. # shape : (batch * sequence_length, 1) negative_log_likelihood_flat = - torch.gather(log_probs_flat, dim=1, index=targets_flat) # shape : (batch, sequence_length) negative_log_likelihood = negative_log_likelihood_flat.view(rebatch) negative_log_likelihood = negative_log_likelihood * weights # shape : (batch_size,) loss = negative_log_likelihood.sum() / (weights.sum() + 1e-13) stats = utils.Statistics(loss=utils.to_cpu(loss) * n_total, n_correct=utils.to_cpu(n_correct), n_words=n_total) return loss, stats
def run(self, need_onnx=False): utils.makedirs(self.model_dir) param_filename = os.path.join(self.model_dir, 'params.npz') params_loaded = self.is_up_to_date(param_filename) if params_loaded: chainer.serializers.load_npz(param_filename, self.model) chainer.config.train = False inputs = utils.as_list(self.model.inputs()) if need_onnx: need_onnx = self.gen_onnx_model(inputs) self.model.to_gpu() gpu_inputs = utils.to_gpu(inputs) gpu_outputs = self.model(*gpu_inputs) gpu_outputs = utils.as_list(gpu_outputs) outputs = utils.to_cpu(gpu_outputs) self.inputs = inputs self.outputs = outputs if need_onnx: self.gen_onnx_test(inputs, outputs) if not params_loaded: chainer.serializers.save_npz(param_filename, self.model) return inputs, outputs
def forward(self, x): layer_outputs = [] yolo_outputs = [] x, backbone_outputs = self.backbone(x) layer_outputs.extend(backbone_outputs) for module in self.cnn_list: x = module(x) layer_outputs.append(x) x, layer_loss = self.first_yolo(x) layer_outputs.append(x) yolo_outputs.append(x) route_output = layer_outputs[-4] x = torch.cat([route_output], 1) layer_outputs.append(x) x = self.second_yolo_conv(x) layer_outputs.append(x) x = self.upsample(x) layer_outputs.append(x) x = torch.cat([x, layer_outputs[8]], 1) layer_outputs.append(x) x = self.second_yolo_conv2(x) layer_outputs.append(x) x = self.second_yolo_conv3(x) layer_outputs.append(x) x, layer2_loss = self.second_yolo(x) layer_outputs.append(x) yolo_outputs.append(x) return to_cpu(torch.cat(yolo_outputs, 1))
def run_first(self, task, inputs, sample_outputs): self.batch_size = inputs[0].shape[0] onnx_filename = task.get_onnx_file() with open(onnx_filename, 'rb') as f: onnx_proto = f.read() logger = tensorrt.Logger() # logger = tensorrt.Logger(tensorrt.Logger.Severity.INFO) builder = tensorrt.Builder(logger) builder.max_batch_size = self.batch_size network = builder.create_network() parser = tensorrt.OnnxParser(network, logger) parser.parse(onnx_proto) engine = builder.build_cuda_engine(network) self.context = engine.create_execution_context() assert len(inputs) + len(sample_outputs) == engine.num_bindings for i, input in enumerate(inputs): assert self.batch_size == input.shape[0] assert input.shape[1:] == engine.get_binding_shape(i) for i, output in enumerate(sample_outputs): assert self.batch_size == output.shape[0] i += len(inputs) assert output.shape[1:] == engine.get_binding_shape(i) self.inputs = utils.to_gpu(inputs) self.outputs = [] for output in sample_outputs: self.outputs.append(cupy.zeros_like(output)) self.bindings = [a.data.ptr for a in self.inputs] self.bindings += [a.data.ptr for a in self.outputs] self.run_task() return utils.to_cpu(self.outputs)
def run_first(self, task, inputs, sample_outputs): self.model = task.model self.model.to_gpu() self.inputs = utils.to_gpu(inputs) gpu_outputs = self.run_task() gpu_outputs = utils.as_list(gpu_outputs) outputs = utils.to_cpu(gpu_outputs) return outputs
def visualize_delta(i, var_dict, grad_dict): for n in [k for k in grad_dict.keys() if 'rnn' in k]: fig, ax = plt.subplots(1,2, figsize=[16,8]) im = ax[0].imshow(to_cpu(par['learning_rate']*grad_dict[n]), aspect='auto') fig.colorbar(im, ax=ax[0]) im = ax[1].imshow(to_cpu(var_dict[n]), aspect='auto') fig.colorbar(im, ax=ax[1]) fig.suptitle(n) ax[0].set_title('Gradient') ax[1].set_title('Variable') plt.savefig('./savedir/{}_delta_{}_iter{:0>6}.png'.format(par['savefn'], n, i), bbox_inches='tight') if par['save_pdfs']: plt.savefig('./savedir/{}_delta_{}_iter{:0>6}.pdf'.format(par['savefn'], n, i), bbox_inches='tight') plt.clf() plt.close()
def forward(self, x): yolo_outputs = [] layer_outputs = [] x, darknet_outputs = self.darknet(x) layer_outputs.extend(darknet_outputs) for i, module in enumerate(self.first_path): x = module(x) layer_outputs.append(x) x, layer_loss = self.first_yolo(x) layer_outputs.append(x) yolo_outputs.append(x) print(f"Yolo dim {x.size()}") route_output = layer_outputs[-4] x = torch.cat([route_output], 1) print(f"First route dim {x.size()}") layer_outputs.append(x) x = self.conv1(x) layer_outputs.append(x) x = self.scale1(x) layer_outputs.append(x) x = torch.cat([x, layer_outputs[61]], 1) print(f"Second route dim {x.size()}") layer_outputs.append(x) for i, module in enumerate(self.second_yolo_conv_blocks): x = module(x) layer_outputs.append(x) x, layer2_loss = self.second_yolo(x) layer_outputs.append(x) yolo_outputs.append(x) print(f"Yolo 2 dim {x.size()}") route_output = layer_outputs[-4] x = torch.cat([route_output], 1) print(f"Third route dim {x.size()}") layer_outputs.append(x) x = self.conv2(x) layer_outputs.append(x) x = self.scale2(x) layer_outputs.append(x) x = torch.cat([x, layer_outputs[36]], 1) print(f"Fourth route dim {x.size()}") layer_outputs.append(x) for i, module in enumerate(self.third_yolo_conv_blocks): x = module(x) layer_outputs.append(x) x, layer3_loss = self.third_yolo(x) yolo_outputs.append(x) #print(f"Yolo output: {x.shape}") layer_outputs.append(x) #print(f"YOLO before: {yolo_outputs}") return to_cpu(torch.cat(yolo_outputs, 1))
def activity_plots(i, model): V_min = to_cpu(model.v[:,0,:,:].T.min()) fig, ax = plt.subplots(4,1, figsize=(15,11), sharex=True) ax[0].imshow(to_cpu(model.input_data[:,0,:].T), aspect='auto') ax[0].set_title('Input Data') ax[1].imshow(to_cpu((model.input_data[:,0,:] @ model.eff_var['W_in']).T), aspect='auto') ax[1].set_title('Projected Inputs') ax[2].imshow(to_cpu(model.z[:,0,:].T), aspect='auto') ax[2].set_title('Spiking') ax[3].imshow(to_cpu(model.v[:,0,0,:].T), aspect='auto', clim=(V_min,0.)) ax[3].set_title('Membrane Voltage ($(V_r = {:5.3f}), {:5.3f} \\leq V_j^t \\leq 0$)'.format(par[par['spike_model']]['V_r'].min(), V_min)) ax[0].set_ylabel('Input Neuron') ax[1].set_ylabel('Hidden Neuron') ax[2].set_ylabel('Hidden Neuron') ax[3].set_ylabel('Hidden Neuron') plt.savefig('./savedir/{}_activity_iter{:0>6}.png'.format(par['savefn'], i), bbox_inches='tight') if par['save_pdfs']: plt.savefig('./savedir/{}_activity_iter{:0>6}.pdf'.format(par['savefn'], i), bbox_inches='tight') plt.clf() plt.close()
def clopath_update_plot(it, cl_in, cl_rnn, gr_in, gr_rnn): update_list = to_cpu([cl_in, cl_rnn, gr_in, gr_rnn]) update_name = ['Clopath W_in', 'Clopath W_rnn', 'Grad W_in', 'Grad W_rnn'] fig, ax = plt.subplots(2,2, figsize=[12,10]) for i, j in itertools.product([0,1], [0,1]): im = ax[i,j].imshow(update_list[i+2*j], aspect='auto') ax[i,j].set_title(update_name[i+2*j]) fig.colorbar(im, ax=ax[i,j]) plt.savefig('./savedir/{}_clopath{:0>6}.png'.format(par['savefn'], it), bbox_inches='tight') if par['save_pdfs']: plt.savefig('./savedir/{}_clopath{:0>6}.pdf'.format(par['savefn'], it), bbox_inches='tight') plt.clf() plt.close()
def forward(self, x, targets=None): img_dim = x.shape[2] loss = 0 layer_outputs, yolo_outputs = [], [] for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)): if module_def["type"] in ["convolutional", "upsample", "maxpool"]: x = module(x) elif module_def["type"] == "route": x = torch.cat([layer_outputs[int(layer_i)] for layer_i in module_def["layers"].split(",")], 1) elif module_def["type"] == "shortcut": layer_i = int(module_def["from"]) x = layer_outputs[-1] + layer_outputs[layer_i] elif module_def["type"] == "yolo": x, layer_loss = module[0](x, targets, img_dim) loss += layer_loss yolo_outputs.append(x) layer_outputs.append(x) yolo_outputs = to_cpu(torch.cat(yolo_outputs, 1)) return yolo_outputs if targets is None else (loss, yolo_outputs)
def plot_grads_and_epsilons(it, trial_info, model, h, eps_v_rec, eps_w_rec, eps_ir_rec): h = to_cpu(h[:,0,:]) eps_v_rec = to_cpu(eps_v_rec) eps_w_rec = to_cpu(eps_w_rec) eps_ir_rec = to_cpu(eps_ir_rec) V_min = to_cpu(model.v[:,0,:,:].T.min()) fig, ax = plt.subplots(8, 1, figsize=[16,22], sharex=True) ax[0].imshow(trial_info['neural_input'][:,0,:].T, aspect='auto') ax[0].set_title('Input Data') ax[0].set_ylabel('Input Neuron') ax[1].imshow(to_cpu(model.z[:,0,:].T), aspect='auto') ax[1].set_title('Spiking') ax[1].set_ylabel('Hidden Neuron') ax[2].plot(to_cpu(model.z[:,0,0]), label='Spike') ax[2].plot(to_cpu(model.v[:,0,0,0]) * -10, label='- Voltage x 10') ax[2].plot(h[:,0], label='Gradient') ax[2].legend() ax[2].set_title('Single Neuron') ax[3].imshow(h.T, aspect='auto', clim=(0, par['gamma_psd'])) ax[3].set_title('Pseudogradient (${} \\leq h \\leq {}$) | Sum: $h = {:6.3f}$'.format(0., par['gamma_psd'], np.sum(h))) ax[3].set_ylabel('Hidden Neuron') ax[4].imshow(to_cpu(model.v[:,0,0,:].T), aspect='auto') ax[4].set_title('Membrane Voltage ($(V_r = {:5.3f}), {:5.3f} \\leq V_j^t \\leq 0$)'.format(par[par['spike_model']]['V_r'].min(), V_min)) ax[4].set_ylabel('Hidden Neuron') ax[5].imshow(eps_v_rec.T, aspect='auto') ax[5].set_title('Voltage Eligibility (${:6.3f} \\leq e_{{v,rec}} \\leq {:6.3f}$)'.format(eps_v_rec.min(), eps_v_rec.max())) ax[5].set_ylabel('Hidden Neuron') ax[6].imshow(eps_w_rec.T, aspect='auto') ax[6].set_title('Adaptation Eligibility (${:6.3f} \\leq e_{{w,rec}} \\leq {:6.3f}$)'.format(eps_w_rec.min(), eps_w_rec.max())) ax[6].set_ylabel('Hidden Neuron') ax[7].imshow(eps_ir_rec.T, aspect='auto') ax[7].set_title('Current Eligibility (${:6.3f} \\leq e_{{ir,rec}} \\leq {:6.3f}$)'.format(eps_ir_rec.min(), eps_ir_rec.max())) ax[7].set_ylabel('Hidden Neuron') # ax[0,1].imshow(trial_info['neural_input'][:,0,:].T, aspect='auto') # ax[1,1].imshow(to_cpu(model.z[:,0,:].T), aspect='auto') # ax[2,1].imshow(h.T, aspect='auto', clim=(0, par['gamma_psd'])) # ax[3,1].imshow(to_cpu(model.v[:,0,0,:].T), aspect='auto') # ax[4,1].imshow(eps_v_rec.T, aspect='auto') # ax[4,1].set_xlabel('Time') # for i in range(4): # ax[i,0].set_xticks([]) # for i in range(5): # ax[i,1].set_xlim(200,350) plt.savefig('./savedir/{}_epsilon_iter{:0>6}.png'.format(par['savefn'], it), bbox_inches='tight') if par['save_pdfs']: plt.savefig('./savedir/{}_epsilon_iter{:0>6}.pdf'.format(par['savefn'], it), bbox_inches='tight') plt.clf() plt.close()
runs = 8 c_all = [] d_all = [] v_all = [] s_all = [] # Run a couple batches to generate sufficient data points for i in range(runs): print('R:{:>2}'.format(i), end='\r') trial_info = stim.make_batch(var_delay=False) model.run_model(trial_info, testing=True) c_all.append(trial_info['sample_cat']) d_all.append(trial_info['sample_dir']) v_all.append(to_cpu(model.v)) s_all.append(to_cpu(model.s)) del model del stim batch_size = runs * par['batch_size'] c = np.concatenate(c_all, axis=0) d = np.concatenate(d_all, axis=0) v = np.concatenate(v_all, axis=1) s = np.concatenate(s_all, axis=1) print('Model run complete.') print('Performing SVM decoding on {} trials.\n'.format(batch_size))
def forward(self, x, targets=None, img_dim=None): # Tensors for cuda support FloatTensor = torch.cuda.FloatTensor if x.is_cuda else torch.FloatTensor LongTensor = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor ByteTensor = torch.cuda.ByteTensor if x.is_cuda else torch.ByteTensor self.img_dim = img_dim num_samples = x.size(0) grid_size = x.size(2) prediction = (x.view(num_samples, self.num_anchors, self.num_classes + 5, grid_size, grid_size).permute(0, 1, 3, 4, 2).contiguous()) # Get outputs x = torch.sigmoid(prediction[..., 0]) # Center x y = torch.sigmoid(prediction[..., 1]) # Center y w = prediction[..., 2] # Width h = prediction[..., 3] # Height pred_conf = torch.sigmoid(prediction[..., 4]) # Conf pred_cls = torch.sigmoid(prediction[..., 5:]) # Cls pred. # If grid size does not match current we compute new offsets if grid_size != self.grid_size: self.compute_grid_offsets(grid_size, cuda=x.is_cuda) # Add offset and scale with anchors pred_boxes = FloatTensor(prediction[..., :4].shape) pred_boxes[..., 0] = x.data + self.grid_x pred_boxes[..., 1] = y.data + self.grid_y pred_boxes[..., 2] = torch.exp(w.data) * self.anchor_w pred_boxes[..., 3] = torch.exp(h.data) * self.anchor_h output = torch.cat( ( pred_boxes.view(num_samples, -1, 4) * self.stride, pred_conf.view(num_samples, -1, 1), pred_cls.view(num_samples, -1, self.num_classes), ), -1, ) if targets is None: return output, 0 else: iou_scores, class_mask, obj_mask, noobj_mask, tx, ty, tw, th, tcls, tconf = build_targets( pred_boxes=pred_boxes, pred_cls=pred_cls, target=targets, anchors=self.scaled_anchors, ignore_thres=self.ignore_thres, ) # Loss : Mask outputs to ignore non-existing objects (except with conf. loss) loss_x = self.mse_loss(x[obj_mask], tx[obj_mask]) loss_y = self.mse_loss(y[obj_mask], ty[obj_mask]) loss_w = self.mse_loss(w[obj_mask], tw[obj_mask]) loss_h = self.mse_loss(h[obj_mask], th[obj_mask]) loss_conf_obj = self.bce_loss(pred_conf[obj_mask], tconf[obj_mask]) loss_conf_noobj = self.bce_loss(pred_conf[noobj_mask], tconf[noobj_mask]) loss_conf = self.obj_scale * loss_conf_obj + self.noobj_scale * loss_conf_noobj loss_cls = self.bce_loss(pred_cls[obj_mask], tcls[obj_mask]) total_loss = loss_x + loss_y + loss_w + loss_h + loss_conf + loss_cls # Metrics cls_acc = 100 * class_mask[obj_mask].mean() conf_obj = pred_conf[obj_mask].mean() conf_noobj = pred_conf[noobj_mask].mean() conf50 = (pred_conf > 0.5).float() iou50 = (iou_scores > 0.5).float() iou75 = (iou_scores > 0.75).float() detected_mask = conf50 * class_mask * tconf precision = torch.sum( iou50 * detected_mask) / (conf50.sum() + 1e-16) recall50 = torch.sum( iou50 * detected_mask) / (obj_mask.sum() + 1e-16) recall75 = torch.sum( iou75 * detected_mask) / (obj_mask.sum() + 1e-16) self.metrics = { "loss": to_cpu(total_loss).item(), "x": to_cpu(loss_x).item(), "y": to_cpu(loss_y).item(), "w": to_cpu(loss_w).item(), "h": to_cpu(loss_h).item(), "conf": to_cpu(loss_conf).item(), "cls": to_cpu(loss_cls).item(), "cls_acc": to_cpu(cls_acc).item(), "recall50": to_cpu(recall50).item(), "recall75": to_cpu(recall75).item(), "precision": to_cpu(precision).item(), "conf_obj": to_cpu(conf_obj).item(), "conf_noobj": to_cpu(conf_noobj).item(), "grid_size": grid_size, } return output, total_loss
def run_SVM_analysis(): print('\nLoading and running model.') model = Model() stim = Stimulus() runs = 8 m_all = [] v_all = [] s_all = [] for i in range(runs): print('R:{:>2}'.format(i), end='\r') trial_info = stim.make_batch(var_delay=False) model.run_model(trial_info) m_all.append(trial_info['sample_cat']) v_all.append(to_cpu(model.v)) s_all.append(to_cpu(model.s)) del model del stim batch_size = runs * par['batch_size'] m = np.concatenate(m_all, axis=0) v = np.concatenate(v_all, axis=1) s = np.concatenate(s_all, axis=1) print('Performing SVM decoding on {} trials.\n'.format(batch_size)) # Initialize linear classifier args = { 'kernel': 'linear', 'decision_function_shape': 'ovr', 'shrinking': False, 'tol': 1e-3 } lin_clf_v = SVC(**args) lin_clf_s = SVC(**args) score_v = np.zeros([par['num_time_steps']]) score_s = np.zeros([par['num_time_steps']]) # Choose training and testing indices train_pct = 0.75 num_train_inds = int(batch_size * train_pct) shuffled = np.random.permutation(batch_size) train_inds = shuffled[:num_train_inds] test_inds = shuffled[num_train_inds:] for t in range(end_dead_time, par['num_time_steps']): print('T:{:>4}'.format(t), end='\r') lin_clf_v.fit(v[t, train_inds, :], m[train_inds]) lin_clf_s.fit(s[t, train_inds, :], m[train_inds]) dec_v = lin_clf_v.predict(v[t, test_inds, :]) dec_s = lin_clf_s.predict(s[t, test_inds, :]) score_v[t] = np.mean(m[test_inds] == dec_v) score_s[t] = np.mean(m[test_inds] == dec_s) fig, ax = plt.subplots(1, figsize=(12, 8)) ax.plot(score_v, c=[241 / 255, 153 / 255, 1 / 255], label='Voltage') ax.plot(score_s, c=[58 / 255, 79 / 255, 65 / 255], label='Syn. Eff.') ax.axhline(0.5, c='k', ls='--') ax.axvline(trial_info['timings'][0, 0], c='k', ls='--') ax.axvline(trial_info['timings'][1, 0], c='k', ls='--') ax.set_title('SVM Decoding of Sample Category') ax.set_xlabel('Time') ax.set_ylabel('Decoding Accuracy') ax.set_yticks([0., 0.25, 0.5, 0.75, 1.]) ax.grid() ax.set_xlim(0, par['num_time_steps'] - 1) ax.legend() plt.savefig('./analysis/svm_decoding.png', bbox_inches='tight') print('SVM decoding complete.')
def export(self): self.results = self._export() if self.label != "": return { self.label + "_" + k : utils.to_cpu(v) for k, v in self.results.items() } else: return { k : utils.to_cpu(v) for k, v in self.results.items() }
def output_behavior(it, trial_info, y): if par['task'] == 'dmswitch': task_info = trial_info['task'] task_names = ['dms', 'dmc'] num_tasks = 2 height = 14 else: task_names = [par['task']] num_tasks = 1 height = 8 match_info, timings = trial_info['match'], trial_info['timings'] fig, ax = plt.subplots(2*num_tasks, 1, figsize=[16,height], sharex=True) for task in range(num_tasks): if par['task'] == 'dmswitch': task_mask = (task_info == task) match = np.where(np.logical_and(task_mask, match_info))[0] nonmatch = np.where(np.logical_and(task_mask, np.logical_not(match_info)))[0] else: match = np.where(match_info)[0] nonmatch = np.where(np.logical_not(match_info))[0] time = np.arange(par['num_time_steps']) y_match = to_cpu(cp.mean(y[:,match,:], axis=1)) y_nonmatch = to_cpu(cp.mean(y[:,nonmatch,:], axis=1)) y_match_err = to_cpu(cp.std(y[:,match,:], axis=1)) y_nonmatch_err = to_cpu(cp.std(y[:,nonmatch,:], axis=1)) c_res = [[60/255, 21/255, 59/255, 1.0], [164/255, 14/255, 76/255, 1.0], [77/255, 126/255, 168/255, 1.0]] c_err = [[60/255, 21/255, 59/255, 0.5], [164/255, 14/255, 76/255, 0.5], [77/255, 126/255, 168/255, 0.5]] for i, (r, e) in enumerate(zip([y_match, y_nonmatch], [y_match_err, y_nonmatch_err])): j = 2*task + i err_low = r - e err_high = r + e ax[j].fill_between(time, err_low[:,0], err_high[:,0], color=c_err[0]) ax[j].fill_between(time, err_low[:,1], err_high[:,1], color=c_err[1]) ax[j].fill_between(time, err_low[:,2], err_high[:,2], color=c_err[2]) ax[j].plot(time, r[:,0], c=c_res[0], label='Fixation') ax[j].plot(time, r[:,1], c=c_res[1], label='Cat. 1 / Match') ax[j].plot(time, r[:,2], c=c_res[2], label='Cat. 2 / Non-Match') for t in range(timings.shape[0]): ax[j].axvline(timings[t,:].min(), c='k', ls='--') fig.suptitle('Output Neuron Behavior') for task in range(num_tasks): j = task*2 ax[j].set_title('Task: {} | Cat. 1 / Match Trials'.format(task_names[task].upper())) ax[j+1].set_title('Task: {} | Cat. 2 / Non-Match Trials'.format(task_names[task].upper())) for j in range(2*num_tasks): ax[j].legend(loc="upper left") ax[j].set_ylabel('Mean Response') ax[0].set_xlim(time.min(), time.max()) ax[2*num_tasks-1].set_xlabel('Time') plt.savefig('./savedir/{}_outputs_iter{:0>6}.png'.format(par['savefn'], it), bbox_inches='tight') if par['save_pdfs']: plt.savefig('./savedir/{}_outputs_iter{:0>6}.pdf'.format(par['savefn'], it), bbox_inches='tight') plt.clf() plt.close()
runs = 8 z_bin = 20 // par['dt'] c_all = [] d_all = [] z_all = [] # Run a couple batches to generate sufficient data points for i in range(runs): print('R:{:>2}'.format(i), end='\r') trial_info = stim.make_batch(var_delay=False) model.run_model(trial_info, testing=True) c_all.append(trial_info['sample_cat']) d_all.append(trial_info['sample_dir']) z_all.append(to_cpu(model.z)) del model del stim batch_size = runs * par['batch_size'] c = np.concatenate(c_all, axis=0) d = np.concatenate(d_all, axis=0) z = np.concatenate(z_all, axis=1) print('Model run complete.') print('Performing ROC decoding on {} trials.\n'.format(batch_size)) local_spikes = np.zeros([par['num_time_steps'], par['n_hidden']]) for t in range(par['num_time_steps'] - z_bin):