From 3435f8dacd04d571e1f19625036b599e8b9de188 Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Sun, 4 Jul 2021 15:29:14 -0500 Subject: [PATCH 1/6] add more constraint options --- featurevis/ops.py | 154 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 113 insertions(+), 41 deletions(-) diff --git a/featurevis/ops.py b/featurevis/ops.py index 676020c..6707c64 100644 --- a/featurevis/ops.py +++ b/featurevis/ops.py @@ -1,8 +1,11 @@ import warnings +import numpy as np import torch import torch.nn.functional as F +from torch import nn from scipy import signal +from scipy.stats import multivariate_normal from featurevis.utils import varargin @@ -23,7 +26,7 @@ def __init__(self, weight=1, isotropic=False): @varargin def __call__(self, x): # Using the definitions from Wikipedia. - diffs_y = torch.abs(x[:, :, 1:] - x[:, :, -1:]) + diffs_y = torch.abs(x[:, :, 1:] - x[:, :, :-1]) diffs_x = torch.abs(x[:, :, :, 1:] - x[:, :, :, :-1]) if self.isotropic: tv = torch.sqrt(diffs_y[:, :, :, :-1] ** 2 + @@ -90,7 +93,7 @@ def __call__(self, x): numer = torch.mm(residuals, residuals.t()) ssr = (residuals ** 2).sum(-1) else: - mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.view(-1))) + mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.reshape(-1))) mean = flat_x.sum(-1) / mask_sum residuals = x - mean.view(len(x), *[1, ] * (x.dim() - 1)) # N x 1 x 1 x 1 numer = (residuals[None, :] * residuals[:, None] * self.mask).view( @@ -102,6 +105,9 @@ def __call__(self, x): sim_matrix = torch.mm(flat_x, flat_x.t()) / (torch.ger(norms, norms) + 1e-9) elif self.metric == 'neg_euclidean': sim_matrix = -torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) + elif self.metric == 'mse': + mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.reshape(-1))) + sim_matrix = - (torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) **2 / mask_sum) else: raise ValueError('Invalid metric name:{}'.format(self.metric)) @@ -166,19 +172,23 @@ class RandomCrop(): height (int): Height of the crop. width (int): Width of the crop """ - def __init__(self, height, width): + def __init__(self, height, width, n_crops=1): self.height = height self.width = width + self.n_crops = n_crops @varargin def __call__(self, x): - crop_y = torch.randint(0, max(0, x.shape[-2] - self.height) + 1, (1,), - dtype=torch.int32).item() - crop_x = torch.randint(0, max(0, x.shape[-1] - self.width) + 1, (1,), - dtype=torch.int32).item() - cropped_x = x[..., crop_y: crop_y + self.height, crop_x: crop_x + self.width] - - return cropped_x + crop_y = torch.randint(0, max(0, x.shape[-2] - self.height) + 1, (self.n_crops,), + dtype=torch.int32) + crop_x = torch.randint(0, max(0, x.shape[-1] - self.width) + 1, (self.n_crops,), + dtype=torch.int32) + crops = [] + for cy, cx in zip(crop_y, crop_x): + cropped_x = x[..., cy: cy + self.height, cx: cx + self.width] + crops.append(cropped_x) + + return torch.vstack(crops) class BatchedCrops(): @@ -288,6 +298,45 @@ class Identity(): def __call__(self, x): return x +class ThresholdLikelihood(): + """ Threshold the latent space of a normal distribution based on radius or likelihood. + Arguments: + size (int): Length of latent vector + radius (float or tensor): Desired radius. + likelihood (float or tensor): Desired likelihood + fixed_radius (boolean): if True, always scale to the fixed radius regardless of original distance; + otherwise, only scale to the desired radius if original distance is larger than desired + """ + def __init__(self, size, radius=None,likelihood=None,fixed_radius=True): + self.size = size + self.fixed_radius = fixed_radius + m = multivariate_normal(np.zeros(self.size),np.diag(np.ones((self.size,self.size)))) + if radius is not None and likelihood is not None: + raise Exception("Only radius or likelihood can be set") + if radius is not None: + self.radius = radius + temp = np.zeros(self.size) + temp[0] = radius + self.likelihood = m.pdf(temp) + else: + self.likelihood = likelihood + def cal_radius(p,dim): + m = multivariate_normal(0) + p /= m.pdf(0)**(dim-1) + x = np.sqrt(-2*np.log(p*np.sqrt(2*np.pi))) + return x + self.radius = cal_radius(self.likelihood,self.size) + + @varargin + def __call__(self, z): + # Scale linearly depending on the distance from origin + dist = (z**2).sum(1).sqrt().unsqueeze(1).repeat(1,self.size) + if self.fixed_radius: + scaled_z = z * (self.radius/(dist+1e-9)) + else: + desired_r = (dist > self.radius) * self.radius + (dist <= self.radius) * dist + scaled_z = z * (desired_r/(dist+1e-9)) + return scaled_z ############################## GRADIENT OPERATIONS ####################################### class ChangeNorm(): @@ -389,6 +438,17 @@ def __call__(self, x, iteration=None): return const * x +class Slicing(): + """ + Slice x by one certain index. + """ + def __init__(self, idx): + self.idx = idx + + @varargin + def __call__(self, x, iteration=None): + return x[:, self.idx] + ########################### POST UPDATE OPERATIONS ####################################### class GaussianBlur(): @@ -454,48 +514,60 @@ def __call__(self, x): fixed_std = x * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) return fixed_std +class ChangeStats(): + """ Change the standard deviation of input. -####################################### LOSS ############################################# -class MSE(): - """ Compute MSE loss between x and a target specified at construction. - - Arguments: - target (torch.tensor): Tensor to match. Broadcastable with expected input. + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. """ - def __init__(self, target): - self.target = target - + def __init__(self, std, mean): + self.std = std + self.mean = mean + + @varargin def __call__(self, x): - return F.mse_loss(x, self.target) + x_std = torch.std(x.view(len(x), -1), dim=-1) + x_mean = torch.mean(x.view(len(x), -1), dim=-1) + fixed_im = (x - x_mean) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + return fixed_im -class CosineSimilarity(): - """ Computes cosine similarity between x and a target specified at construction. - - Similarity is computed over the last axes and averaged across all axes (if any). - - Arguments: - target (torch.Tensor): Tensor to match. Same shape as expected input. +class ChangeMaskStd(): + """ Change the standard deviation of input. + + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. """ - def __init__(self, target): - self.target = target + def __init__(self, std, mask, fix_bg=False, bg=0): + self.std = std + self.mask = mask + self.bg = bg @varargin def __call__(self, x): - return F.cosine_similarity(x, self.target, dim=-1).mean() + mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() + mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) + fixed_std = x * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + if self.fix_bg: + fixed_std = fixed_std * self.mask + self.bg * (1 - self.mask) + return fixed_std +class ChangeMaskStats(): + """ Change the standard deviation of input. -class PoissonLogLikelihood(): - """ Computes (average) poisson log likelihood between x and a target specified at - construction. - - Both target and input need to be strictly positive. - - Arguments: - target (torch.Tensor): Tensor to match. Broadcastable with input + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. """ - def __init__(self, target): - self.target = target + def __init__(self, std, mean, mask, fix_bg=False): + self.std = std + self.mask = mask + self.mean = mean + self.fix_bg = fix_bg @varargin def __call__(self, x): - return -F.poisson_nll_loss(x, self.target, log_input=False) + mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() + mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) + fixed_im = (x - mask_mean) * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + if self.fix_bg: + fixed_im = fixed_im * self.mask + self.mean * (1 - self.mask) + return fixed_im From be0b15d8c927bec20c120698988cfc734a9f257d Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Mon, 13 Sep 2021 00:55:02 -0500 Subject: [PATCH 2/6] fix bug --- featurevis/ops.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/featurevis/ops.py b/featurevis/ops.py index 6707c64..4f88715 100644 --- a/featurevis/ops.py +++ b/featurevis/ops.py @@ -425,16 +425,17 @@ class MultiplyBy(): decay_factor: Compute const every iteration as `const + decay_factor * (iteration - 1)`. Ignored if None. """ - def __init__(self, const, decay_factor=None): + def __init__(self, const, decay_factor=None, low_bound=0.0): self.const = const self.decay_factor = decay_factor + self.low_bound = low_bound @varargin def __call__(self, x, iteration=None): if self.decay_factor is None: const = self.const else: - const = self.const + self.decay_factor * (iteration - 1) + const = max(self.low_bound, self.const + self.decay_factor * (iteration - 1)) return const * x @@ -526,9 +527,9 @@ def __init__(self, std, mean): @varargin def __call__(self, x): - x_std = torch.std(x.view(len(x), -1), dim=-1) - x_mean = torch.mean(x.view(len(x), -1), dim=-1) - fixed_im = (x - x_mean) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + x_std = torch.std(x.view(len(x), -1), dim=-1, keepdim=True) + x_mean = torch.mean(x.view(len(x), -1), dim=-1, keepdim=True) + fixed_im = (x - x_mean[:, :, None, None]) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean return fixed_im class ChangeMaskStd(): From c6604869d34ebfaccc8608f781e33e348a0c9994 Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Mon, 13 Sep 2021 11:15:08 -0500 Subject: [PATCH 3/6] temporary commit --- featurevis.egg-info/PKG-INFO | 16 + featurevis.egg-info/SOURCES.txt | 13 + featurevis.egg-info/dependency_links.txt | 1 + featurevis.egg-info/requires.txt | 4 + featurevis.egg-info/top_level.txt | 1 + .../Untitled-checkpoint.ipynb | 6 + .../.ipynb_checkpoints/core-checkpoint.py | 260 + .../high_low tuning-checkpoint.ipynb | 18445 ++++++++++++++++ .../.ipynb_checkpoints/models-checkpoint.py | 114 + .../.ipynb_checkpoints/ops-checkpoint.py | 562 + .../.ipynb_checkpoints/utils-checkpoint.py | 88 + .../__pycache__/__init__.cpython-36.pyc | Bin 0 -> 153 bytes .../__pycache__/__init__.cpython-38.pyc | Bin 0 -> 184 bytes featurevis/__pycache__/core.cpython-36.pyc | Bin 0 -> 10935 bytes featurevis/__pycache__/core.cpython-38.pyc | Bin 0 -> 4408 bytes .../__pycache__/exceptions.cpython-36.pyc | Bin 0 -> 381 bytes .../__pycache__/exceptions.cpython-38.pyc | Bin 0 -> 393 bytes featurevis/__pycache__/models.cpython-36.pyc | Bin 0 -> 5070 bytes featurevis/__pycache__/models.cpython-38.pyc | Bin 0 -> 4583 bytes featurevis/__pycache__/ops.cpython-36.pyc | Bin 0 -> 21895 bytes featurevis/__pycache__/ops.cpython-38.pyc | Bin 0 -> 21101 bytes featurevis/__pycache__/utils.cpython-36.pyc | Bin 0 -> 3602 bytes featurevis/__pycache__/utils.cpython-38.pyc | Bin 0 -> 3652 bytes 23 files changed, 19510 insertions(+) create mode 100644 featurevis.egg-info/PKG-INFO create mode 100644 featurevis.egg-info/SOURCES.txt create mode 100644 featurevis.egg-info/dependency_links.txt create mode 100644 featurevis.egg-info/requires.txt create mode 100644 featurevis.egg-info/top_level.txt create mode 100644 featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb create mode 100644 featurevis/.ipynb_checkpoints/core-checkpoint.py create mode 100644 featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb create mode 100644 featurevis/.ipynb_checkpoints/models-checkpoint.py create mode 100644 featurevis/.ipynb_checkpoints/ops-checkpoint.py create mode 100644 featurevis/.ipynb_checkpoints/utils-checkpoint.py create mode 100644 featurevis/__pycache__/__init__.cpython-36.pyc create mode 100644 featurevis/__pycache__/__init__.cpython-38.pyc create mode 100644 featurevis/__pycache__/core.cpython-36.pyc create mode 100644 featurevis/__pycache__/core.cpython-38.pyc create mode 100644 featurevis/__pycache__/exceptions.cpython-36.pyc create mode 100644 featurevis/__pycache__/exceptions.cpython-38.pyc create mode 100644 featurevis/__pycache__/models.cpython-36.pyc create mode 100644 featurevis/__pycache__/models.cpython-38.pyc create mode 100644 featurevis/__pycache__/ops.cpython-36.pyc create mode 100644 featurevis/__pycache__/ops.cpython-38.pyc create mode 100644 featurevis/__pycache__/utils.cpython-36.pyc create mode 100644 featurevis/__pycache__/utils.cpython-38.pyc diff --git a/featurevis.egg-info/PKG-INFO b/featurevis.egg-info/PKG-INFO new file mode 100644 index 0000000..8c810b5 --- /dev/null +++ b/featurevis.egg-info/PKG-INFO @@ -0,0 +1,16 @@ +Metadata-Version: 1.1 +Name: featurevis +Version: 0.2.2 +Summary: Visualize features cells are responsive to via gradient ascent +Home-page: https://github.com/cajal/featurevis +Author: Erick Cobos +Author-email: ecobos@bcm.edu +License: MIT +Description: UNKNOWN +Keywords: feature visualization MEI pytorch +Platform: UNKNOWN +Classifier: Development Status :: 3 - Alpha +Classifier: Intended Audience :: Science/Research +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: License :: OSI Approved :: MIT License +Classifier: Natural Language :: EnglishTopic :: Scientific/Engineering :: Bio-Informatics diff --git a/featurevis.egg-info/SOURCES.txt b/featurevis.egg-info/SOURCES.txt new file mode 100644 index 0000000..99af5f2 --- /dev/null +++ b/featurevis.egg-info/SOURCES.txt @@ -0,0 +1,13 @@ +README.md +setup.py +featurevis/__init__.py +featurevis/core.py +featurevis/exceptions.py +featurevis/models.py +featurevis/ops.py +featurevis/utils.py +featurevis.egg-info/PKG-INFO +featurevis.egg-info/SOURCES.txt +featurevis.egg-info/dependency_links.txt +featurevis.egg-info/requires.txt +featurevis.egg-info/top_level.txt \ No newline at end of file diff --git a/featurevis.egg-info/dependency_links.txt b/featurevis.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/featurevis.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/featurevis.egg-info/requires.txt b/featurevis.egg-info/requires.txt new file mode 100644 index 0000000..0ef458d --- /dev/null +++ b/featurevis.egg-info/requires.txt @@ -0,0 +1,4 @@ +torch>=0.4.0 +scipy +numpy +torchvision diff --git a/featurevis.egg-info/top_level.txt b/featurevis.egg-info/top_level.txt new file mode 100644 index 0000000..40de682 --- /dev/null +++ b/featurevis.egg-info/top_level.txt @@ -0,0 +1 @@ +featurevis diff --git a/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/featurevis/.ipynb_checkpoints/core-checkpoint.py b/featurevis/.ipynb_checkpoints/core-checkpoint.py new file mode 100644 index 0000000..bf5c92c --- /dev/null +++ b/featurevis/.ipynb_checkpoints/core-checkpoint.py @@ -0,0 +1,260 @@ +import warnings + +import torch +from torch import optim + +from featurevis.exceptions import FeatureVisException + + +def gradient_ascent(f, x, transform=None, regularization=None, gradient_f=None, + post_update=None, optim_name='SGD', step_size=0.1, optim_kwargs={}, additional_kwargs={}, + num_iterations=1000, save_iters=None, print_iters=100): + """ Maximize f(x) via gradient ascent. + + Objective: f(transform(x)) - regularization(transform(x)) + Update: x_{t+1} = post_update(x_{t} + step_size * gradient_f(x_{t}.grad)) + + Arguments: + f (function): Real-valued differentiable function to be optimized + x (torch.Tensor): Initial guess of the input to optimize. + transform (function): Differentiable transformation applied to x before sending it + through the model, e.g., an image generator, jittering, scaling, etc. + regularization (function): Differentiable regularization term, e.g., natural + prior, total variation, bilateral filters, etc. + gradient_f (function): Non-differentiable. Receives the gradient of x and outputs + a preconditioned gradient, e.g., blurring, masking, etc. + post_update (function): Non-differentiable. Function applied to x after each + gradient update, e.g., keep the image norm to some value, blurring, etc. + optim_name (string): Optimizer to use: SGD or Adam. + step_size (float): Size of the step size to give every iteration. + optim_kwargs (dict): Dictionary with kwargs for the optimizer + num_iterations (int): Number of gradient ascent steps. + save_iters (None or int): How often to save x. If None, it returns the best x; + otherwise it saves x after each save_iters iterations. + print_iters (int): Print some results every print_iters iterations. + + Returns: + optimal_x (torch.Tensor): x that maximizes the desired function. If save_iters is + not None, this will be a list of tensors. + fevals (list): Function evaluations at each iteration. We also evaluate at x_0 + (the original input) so this will have max_iterations + 1 elements. + reg_terms (list): Value of the regularization term at each iteration. We also + evaluate at x_0 (the original input) so this will have max_iterations + 1 + elements. Empty if regularization is None. + + Note: + transform, regularization, gradient_f and post_update receive one positional + parameter (its input) and the following optional named parameters: + iteration (int): Current iteration (starts at 1). + + The number of optional parameters may increase so we recommend to write functions + that receive **kwargs (or use the varargin decorator below) to make sure they will + still work if we add other optional parameters in the future. + """ + # Basic checks + if x.dtype != torch.float32: + raise ValueError('x must be of torch.float32 dtype') + x = x.detach().clone() # to avoid changing original + x.requires_grad_() + + # Declare optimizer + if optim_name == 'SGD': + optimizer = optim.SGD([x], lr=step_size, **optim_kwargs) + elif optim_name == 'Adam': + optimizer = optim.Adam([x], lr=step_size, **optim_kwargs) + else: + raise ValueError("Expected optim_name to be 'SGD' or 'Adam'") + + # Run gradient ascent + fevals = [] # to store function evaluations + reg_terms = [] # to store regularization function evaluations + saved_xs = [] # to store xs (ignored if save_iters is None) + for i in range(1, num_iterations + 1): + # Zero gradients + if x.grad is not None: + x.grad.zero_() + + # Transform input + transformed_x = x if transform is None else transform(x, iteration=i) + + # f(x) + feval = f(transformed_x) + fevals.append(feval.item()) + + if additional_kwargs: + # Stop optimization when feval reaches target activation + if feval >= additional_kwargs['target_level'] * additional_kwargs['mei_activation']: + break + + # Regularization + if regularization is not None: + reg_term = regularization(transformed_x, iteration=i) + reg_terms.append(reg_term.item()) + else: + reg_term = 0 + + # Compute gradient + (-feval + reg_term).backward() + if x.grad is None: + raise FeatureVisException('Gradient did not reach x.') + + # Precondition gradient + x.grad = x.grad if gradient_f is None else gradient_f(x.grad, iteration=i) + if (torch.abs(x.grad) < 1e-9).all(): + warnings.warn('Gradient for x is all zero') + + # Gradient ascent step (on x) + optimizer.step() + + # Cleanup + if post_update is not None: + with torch.no_grad(): + x[:] = post_update(x, iteration=i) # in place so the optimizer still points to the right object + + # Report results + if i % print_iters == 0: + feval = feval.item() + reg_term = reg_term if regularization is None else reg_term.item() + x_std = x.std().item() + print('Iter {}: f(x) = {:.2f}, reg(x) = {:.2f}, std(x) = {:.2f}'.format(i, + feval, reg_term, x_std)) + + # Save x + if save_iters is not None and i % save_iters == 0: + saved_xs.append(x.detach().clone()) + + # Record f(x) and regularization(x) for the final x + with torch.no_grad(): + transformed_x = x if transform is None else transform(x, iteration=i + 1) + + feval = f(transformed_x) + fevals.append(feval.item()) + + if regularization is not None: + reg_term = regularization(transformed_x, iteration=i + 1) + reg_terms.append(reg_term.item()) + print('Final f(x) = {:.2f}'.format(fevals[-1])) + + # Set opt_x + opt_x = x.detach().clone() if save_iters is None else saved_xs + + return opt_x, fevals, reg_terms + + +def contour_walk(f, f_act, x, mei_act, random_dir=None, target_level=0.85, dev_thre=0, seed=0, transform=None, regularization=None, gradient_f=None, + post_update=None, optim_name='SGD', step_size=0.1, optim_kwargs={}, + num_iterations=1000, save_iters=None, print_iters=100): + # Basic checks + if x.dtype != torch.float32: + raise ValueError('x must be of torch.float32 dtype') + x = x.detach().clone() # to avoid changing original + x.requires_grad_() + + # Declare optimizer + if optim_name == 'SGD': + optimizer = optim.SGD([x], lr=step_size, **optim_kwargs) + elif optim_name == 'Adam': + optimizer = optim.Adam([x], lr=step_size, **optim_kwargs) + else: + raise ValueError("Expected optim_name to be 'SGD' or 'Adam'") + + # Run gradient ascent + fevals = [] # to store function evaluations + reg_terms = [] # to store regularization function evaluations + activations = [] + saved_xs = [x.detach().clone()] # to store xs (ignored if save_iters is None) + + torch.manual_seed(seed) + + for i in range(1, num_iterations + 1): + # keep walking until walks off the equal activation contour with small amount of allowed deviation: + # Zero gradients + if x.grad is not None: + x.grad.zero_() + + # Transform input + transformed_x = x if transform is None else transform(x, iteration=i) + + # f(x) + feval = f(transformed_x) + fevals.append(feval.item()) + + # get image activation + act = f_act(transformed_x).item() + activations.append(act) + + # Regularization + if regularization is not None: + reg_term = regularization(transformed_x, iteration=i) + reg_terms.append(reg_term.item()) + else: + reg_term = 0 + + # Random walk or optimize back to the target activation level + if random_dir is None: # keep optimizing back to target activation level + (-feval + reg_term).backward() + if gradient_f is not None: + x.grad = gradient_f(x.grad, iteration=i) + x.grad = x.grad / torch.norm(x.grad) + + elif (act >= mei_act * (target_level - dev_thre)):# and (act <= mei_act * (target_level + dev_thre)): + direction = torch.randn(x.shape).cuda() + if random_dir == 'random': # random walk + x.grad = direction + + elif random_dir == 'ortho': # walk orthogonal to gradient direction + f_act(transformed_x).backward() + grad_norm = torch.sqrt(torch.sum(x.grad**2)) + walk_direction = direction - (torch.dot(direction.view(-1), x.grad.view(-1)) / grad_norm**2) * x.grad + x.grad = walk_direction + + if gradient_f is not None: + x.grad = gradient_f(x.grad, iteration=i) + x.grad = x.grad / torch.norm(x.grad) + + else: + (-feval + reg_term).backward() + if gradient_f is not None: + x.grad = gradient_f(x.grad, iteration=i) + x.grad = x.grad / torch.norm(x.grad) + + if (torch.abs(x.grad) < 1e-9).all(): + warnings.warn('Gradient for x is all zero') + + # Gradient ascent step (on x) + optimizer.step() + + # Cleanup + if post_update is not None: + with torch.no_grad(): + x[:] = post_update(x, iteration=i) # in place so the optimizer still points to the right object + + # Report results + if i % print_iters == 0: + feval = feval.item() + reg_term = reg_term if regularization is None else reg_term.item() + x_std = x.std().item() + print('Iter {}: f(x) = {:.2f}, reg(x) = {:.2f}, std(x) = {:.2f}'.format(i, + feval, reg_term, x_std)) + + # Save x + if save_iters is not None and i % save_iters == 0: + saved_xs.append(x.detach().clone()) + + + # Record f(x) and regularization(x) for the final x + with torch.no_grad(): + transformed_x = x if transform is None else transform(x, iteration=i + 1) + + feval = f(transformed_x) + fevals.append(feval.item()) + + if regularization is not None: + reg_term = regularization(transformed_x, iteration=i + 1) + reg_terms.append(reg_term.item()) + print('Final f(x) = {:.2f}'.format(fevals[-1])) + + # Set opt_x + opt_x = x.detach().clone() if save_iters is None else saved_xs + + return opt_x, activations, fevals, reg_terms \ No newline at end of file diff --git a/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb b/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb new file mode 100644 index 0000000..e7b5e2c --- /dev/null +++ b/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb @@ -0,0 +1,18445 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "import datajoint as dj\n", + "import featurevis\n", + "import numpy as np\n", + "import torch\n", + "from torch import nn\n", + "from featurevis import models\n", + "from featurevis import ops\n", + "from featurevis import utils\n", + "from itertools import product\n", + "\n", + "from staticnet_analyses import base, gabors\n", + "from staticnet_analyses import utils as static_utils\n", + "from staticnet_experiments import models as static_models\n", + "from staticnet_invariance import high_low, zd_deis\n", + "from staticnet_invariance.high_low import * \n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "from featurevis import utils\n", + "\n", + "torch.pi = torch.acos(torch.zeros(1)).item() * 2 # which is 3.1415927410125732\n", + "\n", + "class CombPlaidGenerator(nn.Module):\n", + "\n", + " def __init__(self, device='cpu', image_size=(36, 64), center=(0., 0.), mask_sigma=5):\n", + " \"\"\"\n", + " Combined Plaid generator class.\n", + " Params:\n", + " device: 'cuda' or None\n", + " image_size (tuple of integers): Image height and width.\n", + " center (tuple of integers): The center position of the pattern.\n", + " edge_theta (float): Orientation of the boundary between the two plaids (in radian).\n", + " theta (float): Orientation of the sinusoid (in radian).\n", + " sigma (float): std deviation of the Gaussian.\n", + " Lambda (float): Sinusoid wavelengh (1/frequency).\n", + " psi (float): Phase of the sinusoid.\n", + " gamma (float): The ratio between sigma in x-dim over sigma in y-dim (acts\n", + " like an aspect ratio of the Gaussian).\n", + "\n", + " Returns:\n", + " 2D torch.tensor: An image with two combined plaids.\n", + " \"\"\"\n", + " \n", + " super().__init__()\n", + " self.device = device\n", + " self.image_size = image_size\n", + " self.center = center\n", + " self.mask_sigma = mask_sigma\n", + " \n", + " def gen_gabor(self, theta, Lambda, sigma, psi, gamma):\n", + " ymax, xmax = self.image_size\n", + " xmax, ymax = (xmax - 1)/2, (ymax - 1)/2\n", + " xmin = -xmax\n", + " ymin = -ymax\n", + " (y, x) = torch.meshgrid(torch.arange(ymin, ymax+1), torch.arange(xmin, xmax+1))\n", + " x = x.to(self.device)\n", + " y = y.to(self.device)\n", + " \n", + " # Clip values in reasonable range\n", + " theta.data.clamp_(0, torch.pi)\n", + " psi.data.clamp_(0, torch.pi*2)\n", + " sigma.data.clamp_(3., min(self.image_size)/2) #min(self.image_size)/7, min(self.image_size)/5) #2)\n", + "\n", + " sigma_x = sigma\n", + " sigma_y = sigma / gamma\n", + " \n", + " # Rotation\n", + " x_theta = (x - self.center[0]) * torch.cos(theta) + (y - self.center[1]) * torch.sin(theta)\n", + " y_theta = -(x - self.center[0]) * torch.sin(theta) + (y - self.center[1]) * torch.cos(theta)\n", + " gb = torch.exp(-.5 * (x_theta ** 2 / sigma_x ** 2 + y_theta ** 2 / sigma_y ** 2)) * torch.cos(2 * torch.pi / Lambda * x_theta + psi)\n", + "\n", + " return gb.view(1, 1, *self.image_size)\n", + " \n", + " def gen_plaid(self, gabor1, gabor2):\n", + " return gabor1 + gabor2\n", + " \n", + " def gen_comb_plaid(self, plaid1, plaid2, edge_center_x, edge_center_y, edge_theta):\n", + "\n", + " edge_theta.data.clamp_(-torch.pi/2, torch.pi/2)\n", + " \n", + " ymax, xmax = self.image_size\n", + " xmax, ymax = (xmax - 1)/2, (ymax - 1)/2\n", + " xmin = -xmax\n", + " ymin = -ymax\n", + " (y, x) = torch.meshgrid(torch.arange(ymin, ymax+1), torch.arange(xmin, xmax+1))\n", + " x = x.to(self.device)\n", + " y = y.to(self.device)\n", + " \n", + " px, py = edge_center_x, edge_center_y\n", + " del_x = torch.tensor([1.], dtype=torch.float32).to(self.device)\n", + " qx, qy = (px + del_x, py - del_x * torch.tan(edge_theta))\n", + "\n", + " mask1 = torch.as_tensor((qx - px) * (y - py) - (qy - py) * (x - px), dtype=torch.float32, device=self.device)\n", + " mask1 = torch.sigmoid(mask1)\n", + " mask2 = torch.ones_like(mask1) - mask1\n", + " \n", + " blur = ops.GaussianBlur(self.mask_sigma)\n", + " blur_mask1 = blur(mask1[None, None])\n", + " blur_mask2 = blur(mask2[None, None])\n", + "\n", + " return plaid1 * blur_mask1 + plaid2 * blur_mask2, blur_mask1, blur_mask2, mask1, mask2\n", + " \n", + " @utils.varargin\n", + " def forward(self, params):\n", + " edge_center_x, edge_center_y, edge_theta, theta1, angle1, Lambda1, sigma1, psi1, gamma1, theta2, angle2, Lambda2, sigma2, psi2, gamma2 = params\n", + " gb1 = self.gen_gabor(theta1, Lambda1, sigma1, psi1, gamma1)\n", + " gb2 = self.gen_gabor(theta1+angle1, Lambda1, sigma1, psi1, gamma1)\n", + " plaid1 = self.gen_plaid(gb1, gb2)\n", + " gb3 = self.gen_gabor(theta2, Lambda2, sigma2, psi2, gamma2)\n", + " gb4 = self.gen_gabor(theta2+angle2, Lambda2, sigma2, psi2, gamma2)\n", + " plaid2 = self.gen_plaid(gb3, gb4)\n", + " image, blur_mask1, blur_mask2, mask1, mask2 = self.gen_comb_plaid(plaid1, plaid2, edge_center_x, edge_center_y, edge_theta)\n", + " \n", + " return image, blur_mask1, blur_mask2, plaid1, plaid2, gb1, gb2, gb3, gb4,#, mask1, mask2\n", + " \n", + "# return image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def center_and_crop_image(image, x_offset, y_offset, output_size=(32, 32)):\n", + " \"\"\" Center image to the closest integer and crop it\n", + "\n", + " Arguments:\n", + " image (array): Original image\n", + " x_offset (float): How far to the right (in x) is the image center.\n", + " y_offset (float): How far to the bottom (in y) is the image center.\n", + " output_size (tuple): How far to the right is the image center.\n", + "\n", + " Returns:\n", + " Centered image after cropping to the desired output size.\n", + " \"\"\"\n", + " \n", + " if output_size == (64, 64):\n", + " x_offset = x_offset*2\n", + " y_offset = y_offset*2\n", + " top = (image.shape[0] - output_size[0]) / 2 + y_offset\n", + " bottom = (image.shape[0] - output_size[0]) / 2 - y_offset\n", + " left = (image.shape[1] - output_size[1]) / 2 + x_offset\n", + " right = (image.shape[1] - output_size[1]) / 2 - x_offset\n", + " top, bottom, left, right = (int(round(x)) for x in [top, bottom, left, right])\n", + "\n", + " # Pad image\n", + " pad_amount = ((abs(top) if top < 0 else 0, abs(bottom) if bottom < 0 else 0),\n", + " (abs(left) if left < 0 else 0, abs(right) if right < 0 else 0))\n", + " padded = np.pad(image, pad_amount, mode='edge')\n", + " top, bottom, left, right = (np.clip(top, 0, None), np.clip(bottom, 0, None),\n", + " np.clip(left, 0, None), np.clip(right, 0, None))\n", + "\n", + " # Crop\n", + " cropped = padded[top:padded.shape[0] - bottom, left:padded.shape[1] - right]\n", + " if cropped.shape != output_size:\n", + " raise ValueError('Something wrong with the cropping. This may fail for '\n", + " 'images with odd dimensions.')\n", + "\n", + " return cropped\n", + "\n", + "def make_crop_mei(mei, mask_x, mask_y, output_size=(32, 32)):\n", + " top = (mei.shape[0] - output_size[0]) / 2 + mask_y\n", + " bottom = (mei.shape[0] - output_size[0]) / 2 - mask_y\n", + " left = (mei.shape[1] - output_size[1]) / 2 + mask_x\n", + " right = (mei.shape[1] - output_size[1]) / 2 - mask_x\n", + " top, bottom, left, right = (int(round(x)) for x in [top, bottom, left, right])\n", + "\n", + " # Pad image\n", + " pad_amount = ((abs(top) if top < 0 else 0, abs(bottom) if bottom < 0 else 0),\n", + " (abs(left) if left < 0 else 0, abs(right) if right < 0 else 0))\n", + " padded = np.pad(mei, pad_amount, mode='edge')\n", + " top, bottom, left, right = (np.clip(top, 0, None), np.clip(bottom, 0, None),\n", + " np.clip(left, 0, None), np.clip(right, 0, None))\n", + "\n", + " # Crop\n", + " cropped = padded[top:padded.shape[0] - bottom, left:padded.shape[1] - right]\n", + " if cropped.shape != output_size:\n", + " raise ValueError('Something wrong with the cropping. This may fail for images'\n", + " 'with odd dimensions.')\n", + " return cropped\n", + "\n", + "# centered_mei = center_and_crop_image(mei, x_offset, y_offset)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def rotate_mei(mei, mask, mask_x, mask_y, angle, target_std, target_mean):\n", + " nonmask = np.ones(mask.shape) - mask\n", + " background = (mei * nonmask).sum(axis=(-1, -2), keepdims=True) / nonmask.sum()\n", + " h, w = mei.shape\n", + " pad_h, pad_w = int(h/2), int(w/2)\n", + " pad_mei = np.pad(mei, ((pad_h, pad_h), (pad_w, pad_w)), 'constant', constant_values=background)\n", + " center_mei = np.roll(pad_mei, [-int(round(mask_y)), -int(round(mask_x))], axis=[0, 1])\n", + " rotate_mei = rotate(center_mei, angle, reshape=False)\n", + " shift_back_mei = np.roll(rotate_mei, [int(round(mask_y)), int(round(mask_x))], axis=[0, 1])\n", + " crop_mei = shift_back_mei[pad_h:h+pad_h, pad_w:w+pad_w]\n", + " \n", + " # match contrast within mask\n", + " im_mean = (crop_mei * mask).sum(axis=(-1, -2), keepdims=True) / mask.sum()\n", + " im_std = np.sqrt(np.sum(((crop_mei - im_mean) ** 2) * mask, axis=(-1, -2), keepdims=True) / mask.sum())\n", + " unmasked_im = ((crop_mei - im_mean) / im_std) * target_std + target_mean\n", + " masked_im = unmasked_im * mask + (1 - mask) * target_mean\n", + " \n", + " return masked_im" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "annotation = np.load('/src/static-networks/cell_type.pickle', allow_pickle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [], + "source": [ + "examples = {}\n", + "examples['phase'] = ['106_438', '106_4757', '204_1100', '204_8118', '209_2796']\n", + "examples['texture'] = ['74_5962', '74_5977', '106_643', '106_6192', '204_1004', '204_1108', '88_788']\n", + "examples['corner'] = ['106_3820', '106_189', '166_1943', '204_1259', '204_1366']\n", + "examples['curvature'] = ['74_4890', '46_6214', '46_5701', '74_4470', '74_5651']\n", + "examples['high_low_frequency'] = ['46_879', '46_6369', '74_388', '74_2822', '74_6879', '88_1222', '88_832', '74_5468', '106_6229']\n", + "examples['center_surround'] = ['74_5726', '88_2588', '88_5759', '166_1199', '106_5018']" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [], + "source": [ + "type_key = 'high_low_frequency'\n" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [], + "source": [ + "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", + "[{'group_id': int(key.split('_')[0]), 'neuron_id': int(key.split('_')[1])} for key in examples[type_key]]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [], + "source": [ + "dei_examples = ['204_8118', '74_5962', '204_1366', '74_4470', '88_5759']\n", + "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", + "[{'group_id': int(key.split('_')[0]), 'neuron_id': int(key.split('_')[1])} for key in dei_examples]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(meis)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "all_images = []\n", + "for key, mask_x, mask_y, mei, optcp, param, act in zip(keys, xs, ys, meis, optcps, params, acts/mei_acts):\n", + " images = [mei[None], optcp[None]]\n", + " optcp_params = (OptimizationParameters & key).fetch1()\n", + " image_size = torch.as_tensor([optcp_params['height'], optcp_params['width']], device='cuda')\n", + " center = torch.as_tensor([mask_x, mask_y], device='cuda')\n", + " generator = CombPlaidGenerator('cuda', image_size, center, optcp_params['mask_sigma'])\n", + " tensor_param = torch.as_tensor(list(param[0]), dtype=torch.float32, device='cuda')\n", + " images.append(torch.stack(generator(tensor_param)).cpu().detach().squeeze().numpy())\n", + " all_images.append(np.concatenate(images, axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(len(all_images), 11, figsize=(33, len(all_images)*2))\n", + "for images, act, axis in zip(all_images, acts/mei_acts, axes):\n", + " axis[0].set_title('1.0')\n", + " axis[1].set_title('{:.2f}'.format(act))\n", + " for im, ax in zip(images, axis):\n", + " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "fig.tight_layout()\n", + "fig.savefig('/src/static-networks/my_notebooks/Figures/high_low/texture_cells_combined_plaids.png')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "def get_tuning(key, mask, mask_x, mask_y, param, param_bound_name, param_name1, param_name2=None, bounds=None, n_points=100, add_rotation=False, f_ratio=False):\n", + " \n", + " # Get parameters\n", + " if bounds == None:\n", + " bounds = (CombPlaidSearchRange & key).fetch1()\n", + " if param_bound_name == 'psi':\n", + " values = np.linspace(bounds['lower_{}'.format(param_bound_name)], bounds['upper_{}'.format(param_bound_name)], n_points)\n", + " elif param_bound_name == 'lambda':\n", + " values = 2**np.linspace(1, 5, n_points)\n", + " \n", + " if add_rotation:\n", + " rot_values = np.linspace(-90, 90, n_points)\n", + " \n", + " mask_stats_params = (MaskStatsParameters & key).fetch1()\n", + " optcp_params = (OptimizationParameters & key).fetch1()\n", + "\n", + " # Get predictive model\n", + " model_key = ({'group_id': key['group_id'], 'net_hash': key['net_hash']} if\n", + " optcp_params['use_avg_model'] else key)\n", + " all_keys = (static_models.Model & model_key & 'seed > 1000').fetch('KEY')\n", + " all_models = [(static_models.Model & mk).load_network() for mk in all_keys]\n", + " mean_eyepos = ([0, 0] if (base.Dataset.TrainStats & key).fetch1('norm_eyepos')\n", + " else (base.Dataset.TrainStats & key).fetch1('mean_eyepos'))\n", + " mean_eyepos = torch.tensor(mean_eyepos, dtype=torch.float32,\n", + " device='cuda').unsqueeze(0)\n", + " model = models.Ensemble(all_models, key['readout_key'], eye_pos=mean_eyepos,\n", + " neuron_idx=key['neuron_id'], device='cuda')\n", + "\n", + " # Prepare generator\n", + " mask = torch.as_tensor(mask, dtype=torch.float32, device='cuda')\n", + " image_size = torch.as_tensor([optcp_params['height'], optcp_params['width']], device='cuda')\n", + " center = torch.as_tensor([mask_x, mask_y], device='cuda')\n", + " generator = CombPlaidGenerator('cuda', image_size, center, optcp_params['mask_sigma'])\n", + " transform = ops.ChangeMaskStats(float(mask_stats_params['fixed_mask_std']), float(mask_stats_params['fixed_mask_mean']), mask, fix_bg=True)\n", + " gen = lambda p: transform(generator(p)[0])\n", + "\n", + " param_copy = param.copy()\n", + " images, tunings = [], []\n", + " if f_ratio and param_name2 is not None:\n", + " if not add_rotation:\n", + " for val1, val2 in zip(values, values[::-1]):\n", + " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", + " param_copy[param_name1] = val1\n", + " param_copy[param_name2] = val2\n", + " else:\n", + " param_copy[param_name2] = val1\n", + " param_copy[param_name1] = val2\n", + " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", + " image = gen(tensor_param).cpu().detach().squeeze().numpy()\n", + " images.append(image)\n", + " tensor_image = torch.as_tensor(image[None, None], dtype=torch.float32, device='cuda')\n", + " with torch.no_grad():\n", + " act = model(tensor_image).item()\n", + " tunings.append(act)\n", + " else:\n", + " for rot_val in rot_values:\n", + " for val1, val2 in zip(values, values[::-1]):\n", + " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", + " param_copy[param_name1] = val1\n", + " param_copy[param_name2] = val2\n", + " else:\n", + " param_copy[param_name2] = val1\n", + " param_copy[param_name1] = val2\n", + " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", + " image = gen(tensor_param).cpu().detach().squeeze().numpy()\n", + " image = rotate_mei(image, mask.cpu().detach().squeeze().numpy(), mask_x, mask_y, rot_val, mask_stats_params['fixed_mask_std'], mask_stats_params['fixed_mask_mean'])\n", + " images.append(image)\n", + " tensor_image = torch.as_tensor(image[None, None], dtype=torch.float32, device='cuda')\n", + " with torch.no_grad():\n", + " act = model(tensor_image).item()\n", + " \n", + " tunings.append(act)\n", + " tunings = np.stack(tunings).reshape(n_points, n_points)\n", + " \n", + " else:\n", + " if param_name2 is not None:\n", + " for val1, val2 in product(values, values):\n", + " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", + " param_copy[param_name1] = val1\n", + " param_copy[param_name2] = val2\n", + " else:\n", + " param_copy[param_name2] = val1\n", + " param_copy[param_name1] = val2\n", + " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", + " images.append(gen(tensor_param).cpu().detach().squeeze().numpy())\n", + " with torch.no_grad():\n", + " act = model(gen(tensor_param)).item()\n", + " tunings.append(act)\n", + " tunings = np.stack(tunings).reshape(n_points, n_points)\n", + " else:\n", + " for val in values:\n", + " param_copy[param_name1] = val\n", + " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", + " images.append(gen(tensor_param).cpu().detach().squeeze().numpy())\n", + " with torch.no_grad():\n", + " act = model(gen(tensor_param)).item()\n", + " tunings.append(act)\n", + " return values, images, tunings" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", + "annotation['texture']).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(keys)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.20981174, 0.22388249, 0.34946156, 0.4266715 , 0.48372184,\n", + " 0.51103968, 0.48757452, 0.42270056, 0.35441452, 0.30187755,\n", + " 0.2664458 , 0.24121719, 0.22685729, 0.22035087, 0.2166823 ,\n", + " 0.21254382, 0.20764571, 0.2019327 , 0.19584462, 0.18990151])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(highsf_acts) / 4.5" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(15, 20)" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.stack(dic['high_low']['highphases']).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(15, 20)" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.stack(dic['curvature']['lowphases']).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'curvature'" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ctype" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20-04-2021:21:50:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:34 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:35 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:35 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:36 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:36 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:37 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:37 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:38 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:38 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:39 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:39 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:40 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:40 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:40 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:40 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:42 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:44 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:44 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:46 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:48 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:50 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:50 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:50 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:52 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:52 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:52 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:52 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:53 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:53 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:54 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:56 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:56 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:57 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:57 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:58 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:58 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:58 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:58 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:58 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:58 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:59 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:59 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:50:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:50:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:50:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:50:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:50:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:50:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:50:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:50:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:50:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:50:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:50:59 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:50:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:50:59 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:50:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:50:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:50:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:50:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:00 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:00 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:01 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:01 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:01 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:01 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:01 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:01 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:02 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:02 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:02 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:02 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:02 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:02 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:03 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:03 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:03 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:03 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:03 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:03 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:51:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:51:04 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:51:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:51:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:04 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:04 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:04 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:05 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:05 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:05 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:05 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:05 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:05 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:06 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:06 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:07 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:07 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:08 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:08 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:09 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:09 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:09 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:09 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:09 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:09 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:10 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:10 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:10 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:10 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:10 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:10 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:11 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:11 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:11 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:11 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:11 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:11 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:12 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:12 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:12 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:12 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:12 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:12 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:13 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:13 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:13 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:13 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:13 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:13 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:14 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:14 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:14 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:14 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:14 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:14 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:15 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:15 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:15 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:15 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:15 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:15 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:16 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:16 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:16 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:16 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:16 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:16 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:17 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:17 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:17 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:17 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:17 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:17 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:18 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:18 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:18 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:18 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:18 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:18 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:19 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:19 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:19 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:19 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:19 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:19 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:20 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:20 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:20 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:20 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:20 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:20 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:21 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:21 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:21 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:21 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:22 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:22 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:22 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:22 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:22 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:23 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:23 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:23 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:23 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:51:24 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:51:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:24 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:51:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:24 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:24 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:24 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:26 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:26 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:26 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:26 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:26 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:26 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:27 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:27 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:27 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:27 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:27 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:27 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:28 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:28 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:28 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:28 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:28 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:28 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:29 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:29 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:29 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:29 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:29 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:29 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:31 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:31 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:31 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:33 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:33 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:33 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:33 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:33 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:33 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:35 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:35 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:35 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:35 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:35 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:35 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:36 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:36 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:36 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:36 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:36 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:36 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:37 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:37 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:37 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:37 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:37 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:37 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:38 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:38 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:40 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:42 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:42 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:43 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:43 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:45 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:45 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:46 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:46 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:47 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:47 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:47 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:47 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:48 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:48 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:48 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:48 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:48 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:48 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:49 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:49 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:49 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:49 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:49 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:49 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:51 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:51:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:51:51 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:51:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:51 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:51:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:51 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:51:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:51:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:51:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:51:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:51:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:51:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:51:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:51:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:51:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:51:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:51:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:51:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:51:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:51:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:51:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:51:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:51:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:51:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:07 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:07 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:07 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:07 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:07 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:07 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:07 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:07 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:08 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:08 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:08 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:08 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:08 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:08 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:08 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:09 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:09 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:09 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:09 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:09 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:09 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:10 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:11 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:11 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:12 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:12 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:13 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:13 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:14 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:14 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:15 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:15 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:16 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:16 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:17 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:17 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:18 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:18 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:19 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:21 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:22 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:22 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:23 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:23 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:24 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:24 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:25 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:25 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:26 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:26 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:27 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:29 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:30 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:30 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:31 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:31 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:32 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:32 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:33 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:33 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:35 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:35 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:36 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:36 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:37 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:52:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:52:37 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:52:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:52:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:38 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:38 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:38 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:40 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:40 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:40 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:41 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:41 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:41 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:41 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:42 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:42 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:42 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:42 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:42 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:43 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:43 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:43 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:43 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:43 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:43 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:44 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:44 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:44 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:44 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:44 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:44 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:45 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:45 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:45 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:45 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:45 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:45 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:46 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:46 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:46 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:48 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:48 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:49 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:49 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:49 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:49 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:50 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:50 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:50 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:50 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:51 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:51 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:51 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:51 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:52 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:52 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:53 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:53 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:53 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:53 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:54 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:54 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:54 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:54 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:55 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:55 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:55 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:56 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:56 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:57 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:57 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:58 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:58 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:59 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", + "20-04-2021:21:52:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:52:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:52:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:52:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:52:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", + "20-04-2021:21:52:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:52:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:52:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:52:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:52:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:52:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:52:59 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:52:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:52:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:52:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:52:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:52:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:52:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:52:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:52:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:52:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:52:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:52:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:53:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:53:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:53:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:53:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:53:00 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:53:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:53:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:53:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:53:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:53:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:53:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:53:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:53:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:53:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:53:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:53:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:53:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:53:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:53:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:53:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:53:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:53:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:53:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:53:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:53:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:37 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "20-04-2021:21:54:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "20-04-2021:21:54:37 INFO configs.py 351:\t Found 4449 active trials\n", + "20-04-2021:21:54:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:37 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "20-04-2021:21:54:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:38 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:40 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:40 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:41 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:41 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:43 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:45 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:45 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:46 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:46 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "20-04-2021:21:54:47 INFO configs.py 351:\t Found 4496 active trials\n", + "20-04-2021:21:54:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "20-04-2021:21:54:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:47 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:47 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:47 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:47 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:48 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:48 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:51 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:51 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:51 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:51 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:53 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:54:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:54:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:54:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:54:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:54:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:54:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:54:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:08 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:08 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:55:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:10 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:10 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:11 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:11 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:12 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:12 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:13 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:13 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:14 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:14 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:15 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:15 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:16 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:16 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:17 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:17 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:18 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:19 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:19 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:20 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:20 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:21 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:21 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:22 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:22 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:23 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:23 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:24 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:24 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:25 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:25 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:26 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:27 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:27 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:28 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:28 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:29 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:29 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:30 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:30 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:31 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:31 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:32 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:32 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:33 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:33 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:55:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:21:55:35 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:21:55:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:55:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:21:55:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:55:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:55:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:55:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:55:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:55:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:55:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:55:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:55:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:55:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:55:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:55:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:21:55:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:55:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:55:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:55:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:55:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:55:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The notebook server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--NotebookApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "NotebookApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20-04-2021:21:58:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:58:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:20 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:22 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:22 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:22 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:22 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:23 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:23 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:24 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:24 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:24 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:24 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:26 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:28 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:28 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:28 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:30 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:30 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:30 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:30 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:31 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:31 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:32 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:32 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:32 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:32 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:32 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:32 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:33 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:33 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:34 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:34 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:35 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:35 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:36 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:38 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:40 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:40 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:40 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:40 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:42 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:44 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:44 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:44 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:44 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:44 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:45 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:45 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:45 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:45 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:46 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:46 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:58:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:58:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:58:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:58:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "20-04-2021:21:58:46 INFO configs.py 351:\t Found 4495 active trials\n", + "20-04-2021:21:58:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:58:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "20-04-2021:21:58:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:58:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:58:46 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:58:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:58:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:58:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:58:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:58:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:58:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:58:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:58:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:58:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "20-04-2021:21:58:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:58:47 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:58:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:54 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:54 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:54 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:56 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:56 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:56 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:21:59:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:21:59:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:21:59:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:21:59:59 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:21:59:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:21:59:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:21:59:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:21:59:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:21:59:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:21:59:59 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:21:59:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:21:59:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:21:59:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:21:59:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:21:59:59 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:21:59:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:21:59:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:21:59:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:21:59:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:21:59:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:02 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:02 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:02 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:05 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:05 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:05 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:08 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:08 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:08 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:08 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:11 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:11 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:11 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:11 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:11 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:11 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:11 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:11 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:15 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:15 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:15 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:15 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:15 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:15 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:15 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:15 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:18 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:18 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:18 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:18 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:18 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:18 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:18 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:18 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:21 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:21 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:21 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:21 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:21 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:21 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:21 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:21 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:23 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:23 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:23 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:24 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:24 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:24 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:24 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:24 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:24 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:24 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:24 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:26 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:26 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:26 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:27 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:27 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:27 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:27 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:27 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:27 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:27 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:27 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:29 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:29 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:29 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:29 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:29 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:29 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:29 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:29 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:30 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:30 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:30 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:30 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:30 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:30 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:30 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:30 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:32 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:32 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:32 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:32 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:32 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:32 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:32 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:32 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:33 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:33 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:33 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:33 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", + "20-04-2021:22:00:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:33 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", + "20-04-2021:22:00:33 INFO configs.py 351:\t Found 4479 active trials\n", + "20-04-2021:22:00:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:33 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", + "20-04-2021:22:00:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:33 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:35 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:35 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:35 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:37 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:37 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:37 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:38 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:38 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:38 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:38 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:38 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:38 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:38 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:38 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:39 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:39 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:39 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:39 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:39 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:39 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:39 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:39 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:40 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:40 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:40 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:40 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:40 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:40 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:40 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:40 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:41 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:41 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:41 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:41 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:41 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:41 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:41 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:41 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:42 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "20-04-2021:22:00:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "20-04-2021:22:00:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "20-04-2021:22:00:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", + "20-04-2021:22:00:42 INFO configs.py 351:\t Found 4488 active trials\n", + "20-04-2021:22:00:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "20-04-2021:22:00:42 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", + "20-04-2021:22:00:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "20-04-2021:22:00:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "20-04-2021:22:00:42 INFO configs.py 806:\t Setting cuda=False\n", + "20-04-2021:22:00:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "20-04-2021:22:00:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "20-04-2021:22:00:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "20-04-2021:22:00:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "20-04-2021:22:00:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "20-04-2021:22:00:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "20-04-2021:22:00:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "20-04-2021:22:00:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "20-04-2021:22:00:42 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", + "20-04-2021:22:00:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "20-04-2021:22:00:42 INFO configs.py 377:\t Using statistics source all\n", + "20-04-2021:22:00:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "20-04-2021:22:00:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n" + ] + } + ], + "source": [ + "# 1D tunings\n", + "cell_types = ['texture', 'high_low', 'curvature']\n", + "\n", + "dic = dict()\n", + "for ctype in cell_types:\n", + "\n", + " all_fratios, all_highsfs, all_lowsfs, all_highphases, all_lowphases = [], [], [], [], []\n", + " keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", + " annotation[ctype]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')\n", + " \n", + " for key, mei_act, mask, mask_x, mask_y, param in zip(keys, mei_acts, masks, xs, ys, params):\n", + " _, _, fratio_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20, False, True)\n", + " if param['Lambda1'].item() < param['Lambda2'].item():\n", + " _, _, highsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', n_points=20)\n", + " _, _, lowsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda2', n_points=20)\n", + " _, _, highphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', n_points=20)\n", + " _, _, lowphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi2', n_points=20)\n", + " else:\n", + " _, _, highsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda2', n_points=20)\n", + " _, _, lowsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', n_points=20)\n", + " _, _, highphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi2', n_points=20)\n", + " _, _, lowphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', n_points=20)\n", + "\n", + " all_highsfs.append(np.array(highsf_acts) / mei_act)\n", + " all_lowsfs.append(np.array(lowsf_acts) / mei_act)\n", + " all_highphases.append(np.array(highphase_acts) / mei_act)\n", + " all_lowphases.append(np.array(lowphase_acts) / mei_act)\n", + " all_fratios.append(np.array(fratio_acts) / mei_act)\n", + " \n", + " dic[ctype] = dict(highsfs=all_highsfs, lowsfs=all_lowsfs, highphases=all_highphases, lowphases=all_lowphases, fratios=all_fratios)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(np.stack(dic['high_low']['highphases']).mean(1), np.stack(dic['high_low']['lowphases']).mean(1), label='high_low', color='k')\n", + "\n", + "plt.plot([0, 1], [0, 1], color='gray', linestyle='dashed')\n", + "plt.xlabel('Average activation with phase change in high SF component', fontsize=14)\n", + "plt.ylabel('Average activation with phase\\nchange in low SF component', fontsize=14)\n", + "sns.despine()" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(np.stack(dic['high_low']['highsfs']).mean(1), np.stack(dic['high_low']['lowsfs']).mean(1), label='high_low', color='k')\n", + "plt.plot([0, 1], [0, 1], color='gray', linestyle='dashed')\n", + "plt.xlabel('Average activation with SF change in high SF component', fontsize=14)\n", + "plt.ylabel('Average activation with SF\\nchange in low SF component', fontsize=14)\n", + "sns.despine()" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "text_mei_acts, text_gabor_acts, text_plaid_acts, text_cp_acts = \\\n", + "(high_low.OptimalGabor * high_low.OptimalPlaid() * \\\n", + "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", + "high_low.Optima & annotation['texture']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')\n", + "\n", + "hl_mei_acts, hl_gabor_acts, hl_plaid_acts, hl_cp_acts = \\\n", + "(zd_deis.MaskFixedMEI * high_low.OptimalPlaid() * \\\n", + "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", + "gabors.GaborTuning & annotation['high_low']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')\n", + "\n", + "curve_mei_acts, curve_gabor_acts, curve_plaid_acts, curve_cp_acts = \\\n", + "(zd_deis.MaskFixedMEI * high_low.OptimalPlaid() * \\\n", + "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", + "gabors.GaborTuning & annotation['curvature']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(text_gabor_acts, text_plaid_acts, label='texture')\n", + "plt.scatter(hl_gabor_acts, hl_plaid_acts, label='high_low')\n", + "plt.scatter(curve_gabor_acts, curve_plaid_acts, label='curvature')\n", + "plt.legend()\n", + "plt.plot([1, 4], [1, 4])" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(text_cp_acts, text_plaid_acts, label='texture')\n", + "plt.scatter(hl_cp_acts, hl_plaid_acts, label='high_low')\n", + "plt.scatter(curve_cp_acts, curve_plaid_acts, label='curvature')\n", + "plt.legend()\n", + "plt.plot([1, 4], [1, 4])" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD4CAYAAAD2FnFTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/ZElEQVR4nO3dd3hUVfrA8e+bRgihJ9QQAiS0UCVgQUFQOoIIKiKKFcW14u7q/tYVY9lV3HUtiwUbWBAQEFERpEZQUXoJNfREeiChpr6/P+6gIQxkBjNpvJ/nuc/M3HvPmfdOknlz7zn3HFFVjDHGmPz8ijsAY4wxJZMlCGOMMW5ZgjDGGOOWJQhjjDFuWYIwxhjjVkBxB1BYwsLCNCoqqrjDMMaYUmX58uUHVTXc3bYykyCioqJYtmxZcYdhjDGliojsPNc2u8RkjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEKbEioqIQESKfYmKiCjuj8KYYlFmhtowZc/OlBR01KjiDgOJjy/uEIwpFnYGYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9zyaYIQkZ4isklEkkTkSTfb7xeRtSKySkQWi0hz1/ooETnpWr9KRN72ZZzGGGPO5rM7qUXEHxgDdAOSgaUiMkNV1+fZbYKqvu3avx/wCtDTtW2rqrbxVXzGGGPOz5dnEB2AJFXdpqqZwESgf94dVDU9z8sKgPowHmOMMV7wZYKoC+zO8zrZte4MIvInEdkKjAYezrOpgYisFJEEEbnKh3EaY4xxo9gbqVV1jKo2Ap4AnnKt3gNEqmpbYCQwQUQq5S8rIsNFZJmILDtw4EDRBW2MMRcBXyaIFKBentcRrnXnMhG4HkBVM1T1kOv5cmAr0Dh/AVUdq6pxqhoXHh5eWHEbY4zBtwliKRAjIg1EJAgYDMzIu4OIxOR52QfY4lof7mrkRkQaAjHANh/GaowxJh+f9WJS1WwReRCYDfgDH6hqoog8CyxT1RnAgyJyLZAFHAaGuYp3Ap4VkSwgF7hfVVN9Fasxxpiz+XTCIFWdCczMt+7pPM8fOUe5qcBUX8ZmjDHm/Iq9kdoYY0zJZAnCGGOMW5YgjDHGuGUJwhhjjFs+baQ2xhsRkRGk7D7zVhmJj/fpe9atXJHkR0f69D2MKa0sQZgSI2V3CqMWjPrtdXx8PKM6d/bpe8bHJ/i0fmNKM7vEZIwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi2fJggR6Skim0QkSUSedLP9fhFZKyKrRGSxiDTPs+1vrnKbRKSHL+M0xhhzNp8lCBHxB8YAvYDmwC15E4DLBFVtqaptgNHAK66yzYHBQCzQE3jTVZ8xxpgi4ssziA5AkqpuU9VMYCLQP+8Oqpqe52UFQF3P+wMTVTVDVbcDSa76jDHGFBFfThhUF9id53UycGn+nUTkT8BIIAjomqfsknxl67opOxwYDhAZGVkoQRtjjHEUeyO1qo5R1UbAE8BTXpYdq6pxqhoXHh7umwCNMeYi5csEkQLUy/M6wrXuXCYC119gWWOMMYXMl5eYlgIxItIA58t9MDAk7w4iEqOqW1wv+wCnn88AJojIK0AdIAb4xYexmkISERFFSsrOCy4fHx9/5usEz+eMrhgUzMjLz7qKaYy5QD5LEKqaLSIPArMBf+ADVU0UkWeBZao6A3hQRK4FsoDDwDBX2UQRmQysB7KBP6lqjq9iNYUnJWUno0ZpwTu6ER8vdO486rfXCQkL6Vw/yuPyCTvHX9D7GmPc8+UZBKo6E5iZb93TeZ4/cp6yLwAv+C46Y4wx51PsjdTGGGNKJksQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLZ+O5moKT0RkBCm7i3bOpLr16pK8K7lI37PICUi+OSjc7iZSKG93UXympsywBFFKpOxOYdSCUQXvWIjiuxT8xVnqKYwa1fm8u8QnJDBqVOF89hfFZ2rKDLvEZIwxxi1LEMYYY9yyBGGMMcYtSxDGGGPc8mmCEJGeIrJJRJJE5Ek320eKyHoRWSMi80Skfp5tOSKyyrXM8GWcxhhjzuazXkwi4g+MAboBycBSEZmhquvz7LYSiFPVEyIyAhgN3OzadlJV2/gqPmOMMefnyzOIDkCSqm5T1UxgItA/7w6qukBVT7heLgEifBiPMcYYL/jyPoi6wO48r5OBS8+z/93At3leB4vIMiAbeFFVp+cvICLDgeEAkZGRfzReU0b55+RSf2cakTvTqHHgOJXTMvDPySXH34+2QNX529ldrxLbG1QlO8Ca5Yw5rUTcKCciQ4E4IO8dS/VVNUVEGgLzRWStqm7NW05VxwJjAeLi4rTIAjalQrXUk1y2JJmWa/dT/lQ2uQKHqoeQVrkc2QF+BGTn0ghovngXfgqZgX6si63BLx3qsLd2xeIO35hi58sEkQLUy/M6wrXuDCJyLfB3oLOqZpxer6oprsdtIrIQaAtszV/emPwqHs2g6/wdtFm1lxx/YUOzcNa1CGdHVBUyyp35Kx8fn8Bzf7uS+jvTaL7+AC3X7eeSVXvZ0LQ6c69pyKGwkGI6CmOKny8TxFIgRkQa4CSGwcCQvDuISFvgHaCnqu7Ps74qcEJVM0QkDOiI04BtzLkpXLJiDz1mb8U/J5efLovgx471OBYadN5i2YH+bI2uxtboanzXvRGX/pzCFT/t5oG3lrH4ynr8s4jCN6ak8VmCUNVsEXkQmA34Ax+oaqKIPAssU9UZwMtAKPC5azC0XaraD2gGvCMiuTgN6S/m6/1kzBlCMzOZlgj9Dm5me1QVZlzXmMPVyntdT0ZwAN93rs/ydrXpPmcrnb/fxU+h8EPyIVIjqvsgcmNKLo8ShIhcB3yjqrneVK6qM4GZ+dY9nef5teco9yPQ0pv3MheviLQ0Xpw3j5rHYHb3hiy5LAL9g6OvHg8N4osBzdjQNJxu0xJp/sB7TIq/iR1tGxRS1MaUfJ522bgZ2CIio0WkqS8DMsYbsfv38+bMmVTIyuLqNvDT5fX+cHLIa2OzMNq3g6PVKnLbXz6h7TcrCq1uY0o6jxKEqg7l90bicSLyk4gMFxHr6mGKTct9+3h5zhzSgoN5oHdvfqzsm/fZXh7e/99dbG/bgP7//oouHywAtU5zpuzzuA1CVdNFZApQHngUGAD8RUReV9U3fBSfMW613LeP0XPnciAkhMd69OBQSAikCvEJCV7X5UmZ//vPS/wjBN6uBfd8/D3ff/89T0cBrpOVihUrM3Lko16/tzElmadtEP2BO4Bo4COgg6ruF5EQYD1gCcIUmdj9+89ODgAonesP86quBMYXWCZh5w46d74agE+vVmp99RX/WLmSevU7Me7qLs4+CTYRkCl7PD2DuAH4r6p+n3elawyluws/LGPcq5uezj/nz+dgSAiP9uhBakjR3qegIvznuusQVe74/nty/P35uFOnIo3BmKLiaYLYmz85iMhLqvqEqs7zQVzGnKXSqVO8OG8eCjx5zTVFnhxOUxH+3a8fAbm53L1gAfsrVcL7C1vGlHye9mLq5mZdr8IMxJjzCczJ4fkFC6h57BhPde1KSqVKxRqPivByv34sb9CAv3z1FV0PF2s4xvjEeROEiIwQkbVAU9ecDaeX7cCaognRGHhsyRJa7d/Pv668knU1ahR3OABk+/sz6qab2F29OtPWQY3t+wsuZEwpUtAZxATgOuBL1+PppZ2r66sxPtd7yxZ6JyXxUatWLGhQsm5UOxYczBO33spxf7jl/z6jfPrJ4g7JmEJTUBuEquoOEflT/g0iUk1VU30UlzEARKem8uiSJSyrXZtxrVv/tl5VOH44guNHIjiZXoPsrPJwJI5th+oTFJxOSJVfqVh9B4Hljvs8xv2VKzOgBfyw9igDn5/Kp/8agvrbsOGm9CsoQUwA+gLLAeW3Xt/get3QR3EZQ+WsbOIXLCAtOJjnOnUiB38Op8Syb9sVpKa0JDvj9/s0/QNOAu1J3lMZ1dO/1rlUDNtOWORyakX/QFD5NJ/F+kslmPlwL/r952u6jFvI/Lu7+uy9jCkq500QqtrX9ViyzutN2afKu5s3UfP4cR7s1pcNO3uye10fTh0LJ6DcMapHrKJq7fWEVttB+Ur78PPPIWHneK6KHEbWqYocPxJB2r7GHEppwfZ1vdm+qRNhdRKp33wuoVX2+CTkFX3bUXdjCp0+WcSvTeqw8UoblcaUbudNECJyyfm2q6oNTGN8osfq1Qw6cJARDR9n/I9PcOpYOBXDttKg3WTC6q3Ezz/77EKBcKjCLtKq7+NYg1ROBh4lw//4b+e9B4GDKvidCKeiBlEpuwpEQ45k4a+BhRL3tw/3ptbWfVz/4nTefu9+jtSqUij1GlMcCrrE9J/zbFPAzqNNoat9+DC3zFzGlQEz+XFbLypU2U3La1+map1E8o/Dd8r/OAcq7OBAhR3QABJZgKgfoRnVqHyqJsHZFQjIDcIv15+snABSD0VyNMuPtPBNpNVaBUPhx9zJhJ2IpNbRRlQ5VRvhwgf7yw4K4POnB3H/ve8w8LmpfPjaHeQG+P+hz8OY4lLQJaYuRRWIMQD+ublcNeEwHbKWc0Cq0DDuMyKazUH8fh9pXlFSy6fwa6WNpIY4kxSGZlSDbdAmuBcVM6rjh/sv5ajycCKzNpu+eIb0I3WhXjzh/b7mUMUk9oduIzSjGpFHWhF2IvKCE8WR2lWZ8efruCl+Cl0+XMC8e92Oam9MiVfQJaauqjpfRG5wt11Vp/kmLHNxEoI/asyfDj5LzUo7ofH91Iv9fdRUJZd9odvYVWUNJwOPEpRdnvqHW1PzWEPKZ1ciYdd4Ktcv+B6JkMp7aNPzX+xa25cdq14g7b3HaXXNfzgWsZjdVdaxvuZCKp2qQcyhSwnNrHZBR7L+6liWL9vGlZ/9wPa2DdgW1+iC6jGmOBXUF6+z6/E6N0tfH8ZlLjJZWVCRyczcOZTeVabQ+KGPIXQ74EoMFbaxNOJLNoX/gH9uIM32d+LS3QOJOtKG8tne31UtfrnUbz0DuIrcnCBWz3yGcptuoH1yfxofuJyTgWksr/M126uuAPFqnqzfzHqwJwciwxnwr+mUTztxQXUYU5wKusQ0yvV4Z9GEYy5Gx4/DhE+VY9zAC4FPsOTuXPwCKgBwJHgvSdV/4XjQYSpkVCV2Xxeqn6j3h9oJzrSEtn2eZd28R1k77zFiLv2YOk38CDtRn63VlrKrylpoW5GTtKE83p1NZAUHMu2pG7h3xLv0/e83fD5qUCHFbEzR8OhuHhGpLiKvi8gKEVkuIq+JSIET9IpITxHZJCJJIvKkm+0jRWS9a/iOeSJSP8+2YSKyxbV4N4azKTWOHoVx4+DQvmy+pD/Z1yWRHlqBU6RB8/Wsrj2bbMmk2f7OtPv1uj/UNnAuwRVSadvrBarVXcOWJcPYva4ngbnlaHrwSprvuxrKn2QF73GY7V7XvTe6FgvuuJrYhPW0mL+uUOM2xtc8vd1zInAAGAgMcj2fdL4CIuIPjMEZ1K85cIuINM+320ogTlVbAVOA0a6y1YBRwKVAB2CUiFT1MFZTShw5Ah9+CEfTcvlWeqF8zdwWzdjJ9yzlf1D9EPUPt6Z9yvXUOB5V6IkhL//ADGK7vEF41M9sWz6YnauvAyD8RH1YfglBhLKGj9mD9z27fxjckV2x9ejz6kzqFnbgxviQpwmitqo+p6rbXcvzQM0CynQAklR1m6pm4iSZ/nl3UNUFqnr64uwSIML1vAcwR1VTVfUwMAfo6WGsphRIS3POHE6eVD4Le5DLA5Zydx1YIe+yQxZQjRj4pT1RR9rgrx5PfPiH+Pnl0Oyqd6jZ8Ad2rBrIjlWuX9dT5WnL3VSlEZvlK3bzo1f1qr8f0/92Pf7ZOXwANl2pKTU8TRDfichgEfFzLTcBswsoUxfYned1smvdudwNfOtNWde82MtEZNmBAwcKPAhTMpw4AZ98AidPwj/jptHj4FvccudlHLwHsjhJrA4mlpsgI7jIYxO/XJpc+R41Gy1m5+oBJG9wuqgGUI4WDCZcY9kmc9jBQq/qTa1bje9GdKc7wFtvFXrcxvhCQcN9HxWRdOBenHGZMl3LRGB4YQUhIkOBOOBlb8qp6lhVjVPVuPDw8MIKx/hQRgZ8+qlzeeme/vuJ3XsbzR8qz/Ra38EKaM8DhNGkWGMUUZpc8QFhkcvY+stQ2OtMh+KHP824gVrahp2SwC5+8KreZde1YxbAn/8MmzcXfuDGFLLzJghVraiqlVyPfqoa4Fr8VLWgvoUpQL08ryNc684gItcCfwf6qWqGN2VN6ZKdDZMmwZ490P+mdA6Wu4weQ09yvEI4t+t8+BoCKPqzBnfEL5dmnd6hSu1E2Pgkh7ZEO+vxozHXUUNbsF3mksJSLyoV7gYoVw7uvhtyL6z7rDFFxeMxiUWkqoh0EJFOp5cCiiwFYkSkgYgEAYOBGfnqbAu8g5Mc8s62Mhvo7nrPqkB3Cr6kZUowVZg+HbZvh8uGzmJBg0ZMabidG3dfyXC/DTSg5N207+efRWyXNyB0Kxum3Mjx/c5NeIIfTbie6tqYJGZyCM/PBn4F+O9/YfFiePNN3wRuTCHxtJvrPcD3OF/S8a7HZ85XRlWzgQdd+24AJqtqoog8KyL9XLu9DIQCn4vIKhGZ4SqbCjyHk2SWAs/a3BOl28KFkLj1MLVH3MlPjXoRlp7GN1Pr07L2PAIpnrmlPREQeApa/h/+5TJYO2EImcec+zOcy00DCaU265kCFbyodNgw6NEDnnwSduzwSdzGFAZPzyAeAdoDO13jM7UFjhRUSFVnqmpjVW2kqi+41j2tqqcTwbWqWlNV27iWfnnKfqCq0a7lQ28PzJQca9bA93u/IuCRWPbW+Jih269gzZtZ7G33ITn+QcUdXsHKHaTF4M/IOl6BdZMGk5vt9KryJ4gW3OJcFmsJRzOOelafCIwd6zzee6/1ajIllqcJ4pSqngIQkXKquhGKuSXRlApJKalMl9tgSD+qBYfx5yOTGPfxUjbG3saOBiXvstK5VKyzh6Y3TONocj02fdn/t+/0clSkBbdAIExOnExObo5nFUZGwujRMHeuczOIMSWQpwkiWUSqANOBOSLyJbDTV0GZsmHZ8S/4tEpzNHYil2c+zXBdyogvx5AZVIHvuv+7uMPzWnizDTToOpf961qS/NPlv62vSG3YCMlHk5m7fa7nFd53H3TqBCNHwq+/+iBiY/4YjxKEqg5Q1SOq+gzwD+B94HofxmVKscNs5zMdwDehNyDHanNT2lK6B8bTdu3nNNixgHnX/IvjFQoedbUkqnflYsKarWfb3G4c2VH/9w0HoH2d9ixJXsKGgxs8q8zPD95/HzIz4f777VKTKXG86cV0iYg8DLQCkl13Rxvzm5NZJ6EzvElzknLnwJwXuSntF5pVbUPwycN0/+5xkut2YHm7QruFpsiJQJP+X1K+Wirrp9xIRvrv82J3b9Sd2qG1+XLjlxw+edizCqOj4bnn4KuvYOJEH0VtzIXxtBfT08B4oDoQBnwoIk/5MjBTeqgqMzbNIPbNWOgC4an9yX19I50DnqBpY2cqz2vm/52QEwf5us/bqHj8f0mJFFAug9ibJ5GTGcT6KTeSm+NMThTgF8CNzW8EYOqGqeSqh/c5PPoodOgADz8MNiKAKUE8/Uu9FWivqqNcQ4BfBtzmu7BMaZGUmkTfz/rSf2J/ygeWh/HN2TdmIjE1I+jsmk2kbsovxC17m186PMTe2m2LN+BCUiH8AE36f0n67ki2fdf9t/VVy1elT+M+pBxNYfGuxZ5V5u8PH3wA6enw0EM+itgY73maIH6FM25xLYfd2XxRO555nKfmP0Xsm7Es2rmIV7q/wqz+q2D7HCpXhgEDnMsxkptDn29GcLRibRZ0eba4wy5UNWITqXvpT6T8cikc+H0cypY1WhIbHkvCzgT2HN3jWWWxsfDUU86t5jNmFLy/MUWgoClH3wAUSAMSRWSO63U34Bffh1d6RUREkZJSuB294uPjPdqvYsXKjBz5aKG+92mqyrQN03hs9mPsTt/N0FZDGX3taMKCa9O1K0AVbr4Zypd39m+/9E3q7FnB54MmkVHO+5nfSrqG184lbVd9jm36gLR946lcMw2APjF92JW2iy82fsHwdsMJ8PNgRNonnoDJk2HECOjcGSpX9nH0xpxfQb+1y1yPy4Ev8qxf6JNoypCUlJ2MGlV4vVLi44XOnUd5tG9CgmeJxFsbD27koW8fYu62ubSq2YpPb/iUq+pfBcAjjzijR8A91Kw5AYCKR3/lmvl/J6lRdxJd1+bLGr+AHJoPmsIvb97B1OcHcser4/Dzz6V8YHn6NenHp2s/ZcGOBXRr2K3gyoKCnF5Nl1/uJIu33/b9ARhzHgUN1jf+9AJ8hpMolgMTXOvMReBoxlH+OuevtHyrJUtTlvJGrzdYPnz5b8nhs8/g9dedJOH8mjh6zB6Jf04mM3uPca43lVHlq6VC4/vYvS6SheOu/m19dLVo2tRqw0+7f/L8UlOHDvDYY/DOO874JMYUI097MV0NbMGZIe5NYLMHg/WZMuCztZ/RdExTXv7xZW5vdTubH9rMgx0e/O2SSWIi3HMPXHklvJxnsPaGW+fQInESi676P1KrRRdT9EWo5kTa9FrBok+vYtvyhr+t7t6wOyGBIXy1+SvPezU9+yw0bOgMw3HiRMH7G+MjnjZS/wforqqdVbUTzoxv//VdWKa47T++H+6AIdOGUDu0NkvuXsL7/d+nRp4b3NLT4YYboGJF59J5oNOjlYCsk/T9ZgSHqsXwQ8e/Fs8BFINeD31LWORBvvjnAI6lOqP3lQ8sT6/oXuw5toefk3/2rKKQEHj3XUhKgmee8V3AxhTA0wQRqKqbTr9Q1c1AoG9CMsUpMyeTOdvm8M7yd6AGvNP3HX6+52cujbj0jP1U4c47YetWJznUrv37tqsW/ZNqh7fydd+3yQ4oGfM7FIWg8lkMevpzTh4tz/QXB6C5zmW15uHNaVytMQt2LIAqHlbWtatzavaf/8CyZQXvb4wPeJoglovIeyJytWt5l98bsE0ZsengJt5c+iY/7v6R1jVbwxswvN1w/P38z9r3lVdg2jR48UVnOKHTmgJX/vASq1sNZXuDrkUXfAlRs+F+ej44i61Lo/lx0hUAiAi9Y3ojItDX6QnmkZdfhpo1ncmFsrJ8GLUx7nmaIO4H1gMPu5b1wAhfBWWK1tGMo0xaN4mJiRMJ8g/izjZ30q9JPzjpfv/vv3c62QwcCI8/nmeDKm8BmUGhfNf9P0UReonU7rplNOu0nvnvdyVlYx0AKgdXpmtUV4iGaRumeVZRlSrOpEJr1jgjvxpTxApMECLiD6xW1VdU9QbX8t8804OaUizxQCJvLXuLpMNJXNvgWu5rdx+RlSPPuf+ePXDTTdCokXPz7xmdk8aP52pgzrUvldrB+AqDCFz35xmEVj/G1OcGkXG8HADt67aHvTDyu5GcyPKw8fn66+HGG52G640bfRe0MW4UmCBUNQfYJCLn/tYwpc7JrJNM2zCNKeunULV8Ve5rdx8dIzu6vZx0WlaWkxyOHnUuL1XKe9/bwYPw5z+zGFh5yd0+j7+kK1/xFAOfmsqRvVX45tU+qIKf+MFM2JW2ixcXv+h5ZW+8ARUq2DzWpsh5eompKs6d1PNEZMbpxZeBGd9JSU/hneXvsG7/Oq6ufzV3t72bsJCwAss98YRzM9x77zkjQ5zhr3+FtDTuh1I/GF9hiWy5i87DFrJ2bivWfNfaWbkLbm15K6N/GM3W1K2eVVSzJrz6Kvz4o81jbYqUp3/J/wD6As/idHk9vZhSRFVZ9usyPlzlzGB2d9u76RzV2fnPtgCTJsF//+uMJXfLLfk2JiQ4s6I9/jiJPoi7NLvq1kXUb7WDb17tw6Hd1QEY3W00gf6BPDb7Mc8ruu026N7dmcd6p83VZYpGQWMxBeM0UEcDa4H3VTXb08pFpCfwGuAPvKeqL+bb3gl4FWeOicGqOiXPthzXewLsyjtftfFeTm4OX2/5mlV7VxFdNZoBzQYQEhjiUdmVK50urR07wr/zTwSXkeFMdhMVBU8/DS+9VOixlwQJCQsL3OecY2WFvAvZq/nfA1cAgdStVBeugK+6f4U0FucWVA90rFmTxeB83jNnlum7003JUNBYTOOBLGAR0AtoDjziScWuxu0xOAP7JQNLRWSGqq7Ps9su4A7gz26qOKmqbTx5L3N+p7JPMTlxMtuPbKdTZCeujrra6XLpgf37nXbSsDCYOtUZLugMo0c7jafffOPc4FVGda4fdd7tCTsTGHV6fHM3NtZ/hUmTXgD+hY46SiY5tNK3yB6SyzoeILjAP0WQ+HhnTJOHH4ZPPnHOKozxoYKuLTRX1aGq+g4wCLjKi7o7AEmqus01+9xEoH/eHVR1h6quAazlzUeOnDrCBys/YGfaTvo36U+XBl08Tg4QyKBBTpKYPt25FH6GxERnNrSbb4bevQs58rKladMfaN/+C+Bxvt0STRD+vE4vtsphXmOJ5xU98IAzmN+jj8K+fb4K1xig4ATx29053lxacqkL7M7zOtm1zlPBIrJMRJaIyPXudhCR4a59lh2wmbjOknoylXGrxpGekc7QlkNpU6uNlzW8zqJFTnfWSy7JtyknB+66yxmS+o03Cinisq1bt7eANQybPoC9x0LpTiP6amNeYBH7Oe5ZJf7+Ti+BY8ecMwljfKigBNFaRNJdy1Gg1ennIpLu49jqq2ocMAR4VUQa5d9BVceqapyqxoWHh/s4nNLl4ImDjFs1jsycTIa1HkaDqg28Kr9sRhxwP08+6aZRGpxeNb/84iQH++w9EhiYCQzmWGYQt38xgFwV/k03TpLNKBZ4XlHz5vCPfzhjnHz5pc/iNaag4b79VbWSa6moqgF5nhc0+0sKUC/P6wi8mIVOVVNcj9tw5p8oG3NVFoUQGLdqHLmay7DWw6hdsXbBZfLYtrwh377eC/ia5593s8OWLc7sZ/37O5eXjBc28GrPWczZ1oh//3gFTQhjBHGMZQWJ7Pe8mr/+FVq1ci45HTnis2jNxc2XHdaXAjEi0kBEgoDBgEf3TohIVREp53oeBnTEGd7DFOAUR6C1M/7PHW3uoGZo/oaD89u3tSaTnr6Z8PoHgCH4579vLjfXuWErONjpk289abx27yXLGdQ8kb/P78ovKXUZRWcqUY4/M8fzSk5PLrR3r5MsjPEBnyUIV5vFg8BsYAMwWVUTReRZEekHICLtRSQZuBF4R0ROd6NvBiwTkdXAAuDFfL2fjBuZHGcNH4MfDG051KOb3/JKP1CJT5+8lXIhGQx5cQJw9Oyd3noLFi1yboqoU6dwAr/IiMDYvl9Rp+JRbpk6kMCMqjxNJ2ZJErNI8ryiuDgYOdIZGnz+fN8FbC5aPr3lVVVnqmpjVW2kqi+41j2tqjNcz5eqaoSqVlDV6qoa61r/o6q2VNXWrsf3fRlnWZBNBmv5hAzSYS1enzlkHC/HhCeHkHGiHEP+9SmVwt00MW3b5txO3aMHDBtWSJFfnKqWP8WEG6ay40gVRnzThwe0A9Fajcf5jmxvOvXFx0NMjNNhIN3XzYLmYmNjIpQBSi4bmMox9tGcm8DL74nsTH8mj7qJ/TtqcNMzk6kV7ab7ZHa20+8+IADGjrVLS4WgY+Runum8kAlrWzFx9SWM5lrWywHeY4XnlYSEwLhxsGsX/OUvPovVXJwsQZQB25hLqmwhml5UJ8arsrk5fkx9bhDbljei31++pFH7c4wP9K9/OWMBvfUWRNq4jYXl/65aROf6O/jTzD40P9SRzlqfp1lAGqc8r+SKK5xx18eOhdmzfResuehYgijl9rKSZPmJOtqeurT3qqzmCl++1J+Ni5vR86GZtOm52v2OP//sXMq49dZz9Hk1F8rfT/nkhmkEB2QzaPLNvJDVh4Oc4J8s8q6i556Dpk2dDgTWq8kUEksQpVg6yWzma6poQ6Lp6VVZVZj5Wm/WzGlN17vncekNv7jf8dgxGDoU6taF//2vEKI2+UVUSuezgVNI3F+D/824n2G04VV+ZjuHPa8kOBjGj3cm7Bg50nfBmouKJYhSKosTrGcKQVSkOYMQL36UqjD7zR4sm9Gejrcs5spbz/Pf6mOPORNPf/yxM8OZ8YlujbbxfNf5TFzXkqgVIwnAjyeZ510lHTo4o71++CF8/bVvAjUXFUsQpZCibGQ6mRyjOTcSSHnPy+YK37zah5+nXM6lA5dwzb1zz9ne3B+cYR2eeOLMiaeNTzx55WL6N9nI898M4eYjvZgsifx4xmg1Hnj6aWjRAoYPh9RU3wRqLhqWIEqh3SwmVbbQiO5U8mJ4q9wc4cvR/Vk+oz0dhyyix59mnTM5VNl7hA/AGYTpXMNYm0LlJ8r467+gQZUjfPPRO9TKrcRjzCYX9byScuWcS00HDthYTeYPswRRyqSTzHYWEK6x1PGiUTon249pLwxk9ew2XH3nfK65Z945k4N/ZjY3PvO588sxebKbMb6Nr1QOzmDazZM4dqwaFRc9wy+SwkTWeVfJJZfA3/8On37qzA1rzAUqeBB6U2LkkMkGplGOSjSmL4Jn9yKcOlaOz5+5iW3LG3Htfd/RcfCP592/5n2jqbsjiwHA9Ohor+OMj3/G6zKneTIxT1nXosZ+Puj3JYOnPUL11mN5svJcBtAUf/B4qPZA4Ceg/sCBtAT2FmJ89evWZUdyciHWaEoqSxClyFZmc4rDtOYOAgj2qEza/kpMePJWDu4Ko/8TX5y7K6tL7Px13Lgjix8vi2D6kmR01CivYpT4eEZ1vtqrMqfFJ8SfMTFPws4dF1RPWXBzi0QSD9TguS/e5tCdV/OK/kQOePfzOHAAxo5lT1QUDBlSaDc3il1yvGjYJabSognskRXUoyNVqO9RkT1bavHeA/eStr8yt770SYHJoWbSXvq/PIMfKsHca70bHtwUvmeuXsiNFcJgwwCe1x8h1MsKwsOhWzdISoKlS30SoynbLEGUAsfYB/0gVGsRRRePyqybH8uHD9+Fn38ud73xAQ3bbT/v/hUOH+eWpyZyKjSYQbGQ62+/GsXNT5Rx10+n5eqRnNJc6FLN+0rat4foaJgzBw4eLPwgTZlml5hKgTn8BcpBUwbgR/7xt8+kuX6Q9G+mLryRei12ceMzk6lY/dh5y/hn5XDTM5OpcPg4H75+J3snvluY4V8khPiEBM/29PoSTS34+Q64/D3k7Xdg3+8tCn4SSK5mnbuoU5q1wM4xY7icPNNE/gEiQt269UlO3lEItZmSyhJEKdCN0az5/GMqDK5x3v0yj1dg/ZRBkNyA9gN+pseI7/APzDl/5ar0fm0m9dfsYspTN/BrExvC+8IonesXPMJtAuMZ1dmL2eNcdqXn8OHJqQT0asKjmz+nQqAzA3B8QheP6pt34HtuXj+KuZG3Mr/BPV6/f17xCQsZNeoZ4uNtwMayzq4jlAKh1IJN598nNakRy94awdHkCGh6G70f/rbg5ABc9eki2n2zgu9vvZJ117QspIhNYYss5w8Le5IdlcAHx38lM8e7P90N4Z1YWasnV+76jHppa30UpSlrLEGUcrnZASTN6sHaT28jMOQEbe95D2p94lHZNrNWcc37C1jdrRXz7+7q40jNH7asIRXTo0i96mkmb2hMTq53/8F/2+ghjgTX4oaN/6Jc9nEfBWnKEksQpdjx/TVY8e69pPx8OXXa/8wl944ltKabuRzciP4liX4vz2BrXENm/KWfze9QGuT603fHcAjbxNZGn/PFxmZQQJtUXpkBIXzR9G9UPrWP3kmv+S5OU2ZYgiiFNNeP3T9cwfKxw8k8XoEWQz4lpve3+LuuSxckcs1Obho1mX2NajIp/iZyAj3/kjHFK+bQZTRIvYTAa54m8Wgg8DG56nly3125BQn1b6f1vjm03mtzR5jz82mCEJGeIrJJRJJE5Ek32zuJyAoRyRaRQfm2DRORLa7F5rd0Oba3Jiveu4dtc7tTLTqJuPvfonrMFo/LRyTu5tYnJ5BWozKfvHgrmSHlfBitKWyC0D1pBFlBaURe92fgFqZvbEquF8M1fV9/KDsqt6LPllepfsLLwQDNRcVnCUJE/IExQC+gOXCLiDTPt9su4A5gQr6y1YBRwKVAB2CUiFT1VaylQzm2z+/KineHk5FeieaDJhN780SCQj2/llxnYwpDn/iUY9VC+eg/t3O8mrd3XpmSoNbxaNru6U1ys4+g2nDW7q/Jl14kCRV/pjV7imy/IAZteA7/3EzfBmxKLV+eQXQAklR1m6pmAhNxjSB9mqruUNU1cNYs7T2AOaqaqqqHgTng5Yw4ZciuXQAr2bWoEzVarqX9A2MIj13vVbNBvXW7ue0vn3CyUnnGv3I7R8Mq+ipcUwS6br+LgNxA6PkuXaK2sWZ/Laaub062hw3X6eXCmd7kCWof20K3bWN9HK0prXyZIOrCGYPZJ7vW+bpsmZGRATNnOvO/QAgtb/2YptdPJzDkpFf1NPolidv+8jEnKocw7pVhpNeo7JN4TdEJzaxG5x13QGOoeclEujdKYv3BGkxY24qMbM/alDaHXcGSugO5LGUqTQ7+4NuATalUqhupRWS4iCwTkWUHDhwo7nAKVVISvPWWM4ROhw4ALagWvdXrepovTGTI3z8jtW41Pnj9TtJqVSnsUE0xuTT5BjgAs2L+R1zkVq5vsoEdR6rw0ZrWHM8M9KiOOQ2Hsyc0hv6bRlMpo2z9DZk/zpcJIgWol+d1hGtdoZVV1bGqGqeqceHh4RccaEly8iRMn+4M5R8YCHfdBb16AZx/uIyzqNLxsx+48dkppDSty7hX77A2hzLGXwNgJhwpv4cfIifSutY+bo5dx/7jFfhwVVsOnSh4psEcvyA+b/Y0/prFDRueR7TgmyvNxcOXCWIpECMiDUQkCBgMzPCw7Gygu4hUdTVOd3etK9PWr4cxY2DtWrjqKrjvPqhXr+By+QXlQv/RM+g2di7rOzXn45dv41SoZ8ODm1JmO8Tuu5ofIidwOHgPTcIOcVurNZzICuS9lZew40iVAqtIDYngm5jHiEpbQ+edH/k+ZlNq+GwsJlXNFpEHcb7Y/YEPVDVRRJ4FlqnqDBFpD3wBVAWuE5F4VY1V1VQReQ4nyQA8q6o+nWA3KiKCnSmenuB4xvOJc0KB3kBzatWCoUOhVq0Le89qR48ydzW0TVvFwmGdSbi9M+pnN8GVZd23PsDm6kuYHT2GweueJ7JyGvdcspzP1rXk4zWt6BOzhUtq7zlvHWtqdqPB4RV03vkxyZViSarWoYiiNyWZTwfrU9WZwMx8657O83wpzuUjd2U/AGda5KKwMyXF68lxzseTiXNUYc2+mszaGk1Wjj85Opd77rkW/wu8b63d1q38/YsvKHcSpvxjIOu6triwikypUikjnE47b2deo7FsqfYzMamXUq38Ke5uu4Ip62P5anMT9h2vQPeGW/H3O3df2Jkxj1D72BZu2PACY9u9w5HgC/wvxZQZpbqRujQ7mhHEZ+taMn1TM8JDTnB/3DJg8QUlB/+cHO6aP5+XP/mEtJAQ2rfDksNF5vLdg6h+vB4zG79Glt8pAIIDchjSci2X1d3NLykRjFvVhrRT574xMss/mMmx8fhpDjcljiLA7o+46FmCKAbrD4Tz1rL2bD9ShZ6NtnBHm5WEhZy4oLoa7NvHm++/z+2LFjG7TRtG3HMPGyoUcsCmxPPXQPpuHsmR8ntY2GDcb+v9ROkRvZVBzRPZf6ICY1e0Y2vque85TS1fly+a/o06xzbTM+mNIojclGQ2H0QRysj259ukGFbvq0WdiukMaLqBMC/vaTgtICeHwT/8wLCEBI4FB/P0jTfyffP8N6qbi0nUkTa0/bUPP0V8Tot911D7WMxv22LDD1CzwjE+Xx/LJ2tbcWW9XVwdtcPtJadNYR1ZVG8IV+2eQHKlWFbVumjvUb3oWYIoIrvSKvHFxmaknQqmU+QOOtXfed7rwefTbutWHp41i/oHDzI/NpbXevcmLSSkkCM2pVG3rfexufqPfNX0Ze5Z/hZ++vs1y7CQk9zTdgXfJsWweHd9th6uxg3NNrg9e13Q4C7qHt1Any3/ZW9oNHtDo4vyMEwJYZeYfEwVFu+KZNyqtghwZ5uVdGng/j+3gtRNTSV+8mT+88knBOTk8OQtt/DsoEGWHMxvymdXpNeWh9hTcQtLIqaetT3QP5d+TTZxU/N1HDkVzDvL27H01zpovl/HXPFnarN/cDKgEjcljiI462gRHYEpSSxB+NCJrAA+W9eSedsb0iz8APe1W0a9yule11Px6K+8CYwfM4YOSUm816ULdz7wAEsaNy78oE2p1/zA1TQ+eDkLG3zI4WD33VubhR9kRNxS6ldOY+aWxny2riXpGUFn7HM8qCqTmz9D5Yx93LDxn3YT3UXIEoTPXM47y+PYdrgqvaM3M6jZesoFePcHVvnITnp++wgPvx7NPcBXl1zCrQ89xCedOpEZYFcHjXuC0Hvzo4gK3zR5BcX92WrFcpnc2nINPRttYfuRKry5tAMr9tQ+42wiuXIssxo9SOPUJXTdXmS9zk0JYd8yPvDx6lbA3/GTbO5qu4I6Fb0bJqPmvjV0/GE0LdZNREVY2/JWBq4eT70+fXwTsClzKmfU4Jpt9/Jt49dZVWsWbff2crufCFwakUJM9VRmbGrCV5ubkLg/nL6NN1O1vNNddmmd/tQ8vo2rdk9gf4UG2NfGxcPOIHygfd1fgUnc1265x8nBPzeTQSRy28fdGfF2a5ps+pIllz7Ca49sZ/r149jm25BNGdQ+pT+RR1qxrub8c55FnFat/EmGtV5Fn5jNJB+txFvL2vNzSl3nbEKEb6MfYkflVvTb/DJxHg+pZko7+1fAB5qGHQQeIjhgQYH71jqWRNu9M2m5bx4hpJN2sB7zujzP0vYPcKr8RT5HkvlDBD9uXvcswdmhCAUPtyICcXV+JabaIb7e3JhZSTEk7q9BvyabCAs5weTm8dy7cgTTT03is6PPFsERmOJmCaIYlM9Kp8X+eVyy91tqH9tCtgSyMexKRh6oS8dHxqF+Nke0KRwhWd7P/VE5OIMhLdf+NgzM28viuCpyJx0jhYmxz3Pb8hEMnnQ9T/kgXlOyWIIoIqI5NDi8krZ7v6XZwUUEaBZ7QmOYGf0wa2tcw8nASsxJWMgVlhxMCSACrWvto1G1VGYnRbNwZwPWHajBdY0r8R0D+CJlMuMAcnPBz65Ul1WWIHysysk9tNk3izZ7Z1MlYx8nAyqyvE5fVtbsxd6KMQVXYEwxCg3KYmDzDbQ6tI9vtjTmw1VtgT/zRecrGJzwKPztb/DSS8UdpvERSxC+kJXFrcCw1SNpcGQlirC1ahxzGt7HprCOZPsFFVhFiSDOqLTeik/o4oNgygj5Y59PfMLZP4+C6qsYHMbISz+/4PcEiKmeygNVlrJgexRLUtpx+/I4BvM9Y0ePRqKiYMSIP1S/KZksQRQWVdizB1asgHXr+ARIPbWP+VF3sapmD9KDaxR3hN5TGDWqs1dF4hMS6Fx/2AW9XcL48RdUrlRR6DzsAj+fnTvoXD8q37rxBX7ehfW5Bvnn0CN6K0tSviU0dDjvHZvI37vcR9SDDzozW/XtWyjvY0oOSxB/VEaGMwXc8uWwdy8EBEBsLJ1Xr6Zrh49R8fz6rHD+SYYSEhZ6XFf8Bfznb4xnfuXee+G557oSNeNbuHoN3HwzJCRAXFxxB2cKkSWIC/Xrr05SWLsWsrKgZk3o3RtatoTgYL5fvZouXiQHAIVzTjIUnxB/1n+P55KwM4FRnb37z//M90q44LLm4uC0Sy+G0FD4+mu47DLo0wcWL4YYa1srKyxBeCM315k4eskSSElxzhZatIB27aBuXafrR4kgf/hL/nR5SxamQLVqwaxZzkTq117rJIkLmUzdlDiWIDyRkQErVzqJIS0NqlWDnj2hdWsIDi7u6NzQC24HgN+vdSdQ8PXts8teBO0I5mxNm8Ls2dClC3TrBt9/DzVKYbubOYNPE4SI9AReA/yB91T1xXzbywEfAe2AQ8DNqrpDRKKADcAm165LVPV+X8bqVno6/PyzcykpIwMiI53E0Lix9f02Jr9LLoFvvoHu3aFHD1iwAKpUKe6ozB/gswQhIv7AGKAbkAwsFZEZqro+z253A4dVNVpEBgMvATe7tm1V1Ta+iu+80tKc0+QVK5zeSc2bw+WXO5eRjDHnduWVMG0a9Ovn9GqaPRsq2By4pZUvzyA6AEmqug1ARCYC/YG8CaI/8Izr+RTgfyLFeCE/PR0WLXIuJ6lC27bQsSNUtTGRjPFYz54wYYLTs6lvX/jqK6cx25Q6vkwQdYHdeV4nA5eeax9VzRaRNKC6a1sDEVkJpANPqeqi/G8gIsOB4QCRkZEXHmlyMm8AvP66kxjatHEa3Oz02JgLM2gQfPQR3H67kzBmzoRKlYo7KuOlktpIvQeIVNVDItIOmC4isap6xnRsqjoWGAsQFxd3YRM8b9kCLVpwHziNzpYYjCkct94KQUEwZIjTLjFrlv1tlTK+bGlNAfL2dYtwrXO7j4gEAJWBQ6qaoaqHAFR1ObAV8M38mtHR8OyzxABcd539AhtTmG68EaZMcdrzrrkGDh0q7oiMF3yZIJYCMSLSQESCgMHAjHz7zABO96McBMxXVRWRcFcjNyLSEIgBH82ZIwJPPMFOn1RujKF/f5g+HRITnW6we9zPk21KHp8lCFXNBh4EZuN0WZ2sqoki8qyI9HPt9j5QXUSSgJHAk671nYA1IrIKp/H6flVN9VWsxhgf693baazetg2uuAI2bSq4jCl2Pm2DUNWZwMx8657O8/wUcKObclOBqb6MzRhTxLp1g4ULnSE5rrjCGaLj8suLOypzHna3lzGm6MTFwY8/OqMRdO0KkyYVd0TmPCxBGGOKVqNGTpKIi4PBg+Ef/3DGOTMljiUIY0zRCw+HuXPhrrvg+edh4EDnRlVToliCMMYUj3Ll4L334LXXnAbsdu2cUQxMiWEJwhhTfETg4YedxuuTJ51G67feckY0MMXOEoQxxit5Zz4UkcJZrrqKsJQUZmZkwAMPMMPPj9rn2T8qIqJYP4PToiIiCu8z+AOLrz6PkjrUhjGmhDo982F8Qjw6alQhV67w88/0mzePfoGBzv0TsbFnTcYlJWRK3Z0pKYX/GVwAX30edgZhjCk5RJzpS++7D6pXh6lT4bPPINXuky0OliCMMSVPWBjceaczyN/OnfDmm047RVZWcUd2UbFLTMaYksnPz2m0btECvvsOEhKcQf86d7YvriJiZxDGmJKtYkXnPok77oDKleHrr0kEGD8eMjOLObiyzRKEMaZ0qF/fubFu8GBOgZMwGjaEl1+GI0eKN7YyyhKEMab0EIEmTWgNzix1jRvDX/8KtWvD0KGwYIEN21GI7FKeMaZ06tXLWVauhHffdebB/vRTiIiAAQPghhvgyishoBR9zanCiRNw7BgcPeo8HjsGx49Ddrb7RZUxPgqnFH1yxhjjRtu2Ti+nf/8bpk1zZrB791144w1nHuzOnZ2RYzt2hJYtITi46GPMzj77S9/d62PH3N9FHhjoLAEBZy8iyNklCoUlCGNM2RAS4lxmGjrU+aKdNQvmzIH5852xnsD5Qo2NhVatnOmGo6Odto2wMGepWtXpPVUQVUhPpyFAcrLzX//x478/5v/yP3XKfT0VKjiN8KGhULOm8xga+vu600tQ0HnDeSA+nhFefViesQRhjCl7QkNh0CBnAdi9G375xekmu3y502X2k0/O/m/dz89JEsHBZ/6XruqMFXV6OXECVNkK8P77Z9YREPD7l3x4ODRo4P6Lv0IFz5JRMbIEYYwp++rVc5aBA39fd+oUbN/uJI+DB53lwAHnMTMTcnLOuM5PSAiUL//7Y9Wq3P7443w0ZIiz7vQSFHTW0CCllSUIY8zFKTgYmjVzlgv08eOP81FMTCEGVbL49PxGRHqKyCYRSRKRJ91sLycik1zbfxaRqDzb/uZav0lEevgyTmOMMWfzWYIQEX9gDNALaA7cIiLN8+12N3BYVaOB/wIvuco2BwYDsUBP4E1XfcYYY4qIL88gOgBJqrpNVTOBiUD/fPv0B8a7nk8BrhERca2fqKoZqrodSHLVZ4wxpoiI+mjmJhEZBPRU1Xtcr28DLlXVB/Pss861T7Lr9VbgUuAZYImqfuJa/z7wrapOyfcew4HhrpdNgE0+OZjCFwYcLO4gCklZOZaychxQdo6lrBwHlOxjqa+q4e42lOpGalUdC4wt7ji8JSLLVDWuuOMoDGXlWMrKcUDZOZaychxQeo/Fl5eYUoB6eV5HuNa53UdEAoDKwCEPyxpjjPEhXyaIpUCMiDQQkSCcRucZ+faZAQxzPR8EzFfnmtcMYLCrl1MDIAb4xYexGmOMycdnl5hUNVtEHgRmA/7AB6qaKCLPAstUdQbwPvCxiCQBqThJBNd+k4H1QDbwJ1XN8VWsxaDUXRY7j7JyLGXlOKDsHEtZOQ4opcfis0ZqY4wxpVvJHgjEGGNMsbEEYYwxxi1LED7kwVAjI0VkvYisEZF5IlK/OOL0hAfHcr+IrBWRVSKy2M1d8yVCQceRZ7+BIqIiUmK7JnrwM7lDRA64fiarROSe4oizIJ78TETkJtffSqKITCjqGD3lwc/kv3l+HptF5EgxhOk5VbXFBwtOw/xWoCEQBKwGmufbpwsQ4no+AphU3HH/gWOplOd5P2BWccd9Icfh2q8i8D2wBIgr7rj/wM/kDuB/xR1rIRxHDLASqOp6XaO44/4jv1959n8Ip/NOscd+rsXOIHynwKFGVHWBqp5wvVyCc79HSeTJsaTneVkBKIm9HzwZ/gXgOZxxwc4xy0uJ4OmxlHSeHMe9wBhVPQygqvuLOEZPefszuQX4rEgiu0CWIHynLrA7z+tk17pzuRv41qcRXTiPjkVE/uQaLmU08HARxeaNAo9DRC4B6qnqN0UZ2AXw9PdroOsS5hQRqedme3Hz5DgaA41F5AcRWSIiPYssOu94/DfvupzcAJhfBHFdMEsQJYCIDAXigJeLO5Y/QlXHqGoj4AngqeKOx1si4ge8Ajxe3LEUkq+AKFVtBczh94ExS5sAnMtMV+P81/2uiFQpzoAKwWBgipbw+7ssQfiOR8OFiMi1wN+BfqqaUUSxecvboU8mAtf7MqALVNBxVARaAAtFZAdwGTCjhDZUF/gzUdVDeX6n3gPaFVFs3vDkdysZmKGqWeqM7rwZJ2GUNN78nQymhF9eAqyR2lcLzn8923BOI083WMXm26ctTqNWTHHHWwjHEpPn+XU4d8sXe+zeHke+/RdSchupPfmZ1M7zfADOCMnFHvsFHEdPYLzreRjOZZzqxR37hf5+AU2BHbhuVC7JS6kezbUkU8+GGnkZCAU+d6bBYJeq9iu2oM/Bw2N50HU2lAUc5vcxtkoMD4+jVPDwWB4WkX44w9Wk4vRqKlE8PI7ZQHcRWQ/kAH9R1UPFF7V7Xvx+DcaZ76YkduQ4gw21YYwxxi1rgzDGGOOWJQhjjDFuWYIwxhjjliUIY4wxblmCMMYY45YlCGOMMW5ZgjDGGOPW/wMyJvHZ/hUdhQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(np.stack(dic['high_low']['fratios']).mean(1), label='high_low', color='r', kde=True, stat='probability')\n", + "sns.histplot(np.stack(dic['curvature']['fratios']).mean(1), label='curvature', color='b', kde=True, stat='probability')\n", + "sns.histplot(np.stack(dic['texture']['fratios']).mean(1), label='texture', color='g', kde=True, stat='probability')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(np.stack(dic['texture']['highsfs']).mean(1), np.stack(dic['texture']['lowsfs']).mean(1))\n", + "plt.plot([0, 1], [0, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.74978808, 0.58200077, 0.57170733, 0.59208932, 0.39422424,\n", + " 0.49421167, 0.56800983, 0.7208392 , 0.52284125, 0.75522118,\n", + " 0.38187901, 0.44086938, 0.47139352, 0.51878621, 0.56917853,\n", + " 0.77557691, 0.63834333, 0.54907664, 0.46187575, 0.80938305,\n", + " 0.59225197, 0.60802239, 1.05168903, 0.45641054, 0.60753648,\n", + " 0.61701107, 0.83593175, 0.67566611, 0.47884295, 0.41047811,\n", + " 0.80848538, 0.50228611])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.stack(dic['high_low']['lowsfs']).mean(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([7.6698500394662075], dtype=object)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "params[1]['Lambda2']" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "07-04-2021:04:05:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:05:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:05:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:05:54 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:05:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:05:54 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:05:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:05:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:05:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:05:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:05:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:05:54 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:05:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:05:54 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:05:54 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:05:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:05:54 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:05:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:05:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:05:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:05:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:05:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:05:55 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:05:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:05:55 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:05:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:05:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:05:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:05:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:05:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:05:55 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:05:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:05:55 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:05:55 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:05:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:05:55 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:05:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:05:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:05:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:05:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:05:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:05:55 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:05:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:05:55 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:05:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:05:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:05:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:05:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:05:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:05:55 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:05:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:05:55 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:05:55 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:05:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:05:55 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:05:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:05:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:05:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:05:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:05:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:05:56 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:05:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:05:56 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:05:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:05:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:05:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:05:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:05:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:05:56 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:05:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:05:56 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:05:56 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:05:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:05:56 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:05:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:05:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:05:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:05:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:05:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:05:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:02 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:02 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:02 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:02 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:02 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:02 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:03 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:03 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:03 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:03 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:03 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:03 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:03 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:03 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:03 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:03 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:03 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:03 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:04 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:04 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:04 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:04 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:04 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:04 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:10 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:10 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:10 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:10 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:10 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:10 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:10 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:10 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:10 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:10 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:10 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:11 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:11 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:11 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:11 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:11 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:11 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:11 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:11 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:11 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:11 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:18 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:18 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:18 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:18 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:18 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:18 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:18 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:18 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:18 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:18 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:18 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:18 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:19 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:19 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:19 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:19 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:19 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:19 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:19 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:04:06:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:19 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:04:06:19 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:04:06:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:19 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:04:06:19 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:04:06:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:19 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:25 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:25 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:25 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:26 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:26 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:26 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:26 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:26 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:26 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:27 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:27 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:27 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:33 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:33 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:33 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:33 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:33 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:33 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:34 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:34 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:34 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:34 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:34 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:34 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:41 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:41 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:41 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:41 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:41 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:41 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:42 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:42 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:48 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:48 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:48 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:49 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:49 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:49 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:49 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:49 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:49 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:50 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:50 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:50 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:50 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:50 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:56 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:56 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:56 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:56 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:56 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:56 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:57 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:57 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:57 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:06:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:06:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:06:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:06:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:06:57 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:06:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:06:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:06:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:06:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:06:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:06:57 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:06:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:06:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:06:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:06:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:06:57 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:06:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:06:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:06:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:06:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:06:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:06:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:05 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:05 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:05 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:05 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:05 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:11 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:11 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:11 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:11 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:11 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:12 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:12 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:12 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:12 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:12 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:12 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:12 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:12 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:12 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:12 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:13 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:13 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:13 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:13 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:13 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:19 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:19 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:19 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:19 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:19 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:19 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:19 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:19 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:19 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:19 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:20 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:20 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:20 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:04:07:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:20 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:04:07:20 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:04:07:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:04:07:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:20 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:28 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:28 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:28 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:28 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:28 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:34 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:34 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:34 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:34 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:34 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:35 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:35 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:35 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:35 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:35 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:35 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:35 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:35 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:35 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:35 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:36 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:36 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:36 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:36 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:36 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:42 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:42 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:42 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:42 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:42 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:42 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:43 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:43 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:43 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:43 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:43 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:43 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:43 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:43 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:43 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:43 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:49 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:49 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:49 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:49 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:49 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:50 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:50 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:50 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:50 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:50 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:50 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:50 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:50 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:50 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:50 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:51 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:04:07:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:51 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:04:07:51 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:04:07:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:51 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:04:07:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:51 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:57 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:07:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:57 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:07:57 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:07:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:57 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:07:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:57 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:57 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:07:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:07:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:08:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:08:05 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:08:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:08:05 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:08:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:08:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:08:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:08:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:08:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:08:05 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:08:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:08:05 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:08:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:08:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:08:05 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:08:05 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:08:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:08:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:08:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:08:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:08:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:08:05 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:08:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:08:05 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:08:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:08:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:08:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:08:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:08:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:08:05 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:08:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:08:05 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:08:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:08:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:08:05 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:08:05 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:08:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:08:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:08:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:08:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:08:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:08:06 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:08:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:08:06 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:08:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:08:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:08:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:08:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:08:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:08:06 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:08:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:08:06 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:08:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:08:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:08:06 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:08:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:08:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:08:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:08:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:08:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:04:08:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:04:08:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:04:08:06 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:04:08:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:04:08:06 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:04:08:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:04:08:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:04:08:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:04:08:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:04:08:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:04:08:06 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:04:08:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:04:08:06 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:04:08:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:04:08:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:04:08:06 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:04:08:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:04:08:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:04:08:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:04:08:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:04:08:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:04:08:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" + ] + } + ], + "source": [ + "# 2D tunings\n", + "all_lambda_images, all_lambda_acts, all_psi_images, all_psi_acts, all_fori_images, all_fori_acts = [], [], [], [], [], []\n", + "for key, mask, mask_x, mask_y, param in zip(keys, masks, xs, ys, params):\n", + " lambda_values, lambda_images, lambda_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20)\n", + " psi_values, psi_images, psi_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', 'psi2', None, 20)\n", + " psi_values, psi_images, psi_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', 'psi2', None, 20)\n", + "\n", + " all_lambda_images.append(lambda_images)\n", + " all_lambda_acts.append(lambda_acts)\n", + " all_psi_images.append(psi_images)\n", + " all_psi_acts.append(psi_acts)" + ] + }, + { + "cell_type": "code", + "execution_count": 315, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "07-04-2021:08:44:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:21 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:21 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:22 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:22 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:22 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:22 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:22 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:22 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:22 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:22 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:22 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:22 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:23 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:23 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:23 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:23 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:23 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:23 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:23 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:23 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:23 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:23 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:23 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:23 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:28 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:28 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:28 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:28 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:28 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:28 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:29 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:29 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:29 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:29 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:29 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:29 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:29 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:29 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:29 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:29 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:29 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:29 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:30 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", + "07-04-2021:08:44:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:30 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", + "07-04-2021:08:44:30 INFO configs.py 351:\t Found 4425 active trials\n", + "07-04-2021:08:44:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:30 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", + "07-04-2021:08:44:30 INFO configs.py 314:\t Number of batches in the loader will be 74\n", + "07-04-2021:08:44:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:30 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:35 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:35 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:35 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:35 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:36 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:36 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:36 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:36 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:36 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:41 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:41 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:41 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:41 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:41 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:41 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:42 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:42 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:42 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:42 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:47 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:47 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:47 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:48 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:48 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:48 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:48 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:48 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:48 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:49 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:49 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:49 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:54 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:54 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:55 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:44:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:44:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:44:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", + "07-04-2021:08:44:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:44:55 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:44:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:44:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:44:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:44:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:44:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", + "07-04-2021:08:44:55 INFO configs.py 351:\t Found 4495 active trials\n", + "07-04-2021:08:44:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:44:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", + "07-04-2021:08:44:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:44:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:44:55 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:44:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:44:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:44:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:44:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:44:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:44:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:00 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:00 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:00 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:00 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:00 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:00 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:00 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:00 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:00 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:00 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:01 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:01 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:01 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:01 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:01 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:01 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:01 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:01 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:01 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:01 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:06 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:06 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:06 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:07 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:07 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:07 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:07 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:07 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:07 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", + "07-04-2021:08:45:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:08 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", + "07-04-2021:08:45:08 INFO configs.py 351:\t Found 4449 active trials\n", + "07-04-2021:08:45:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", + "07-04-2021:08:45:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:08 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:13 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:08:45:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:13 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:08:45:13 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:08:45:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:13 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:08:45:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:13 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:13 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:08:45:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:13 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:08:45:13 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:08:45:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:13 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:08:45:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:13 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:14 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:08:45:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:14 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:08:45:14 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:08:45:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:14 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:08:45:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:14 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "07-04-2021:08:45:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "07-04-2021:08:45:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "07-04-2021:08:45:14 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", + "07-04-2021:08:45:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "07-04-2021:08:45:14 INFO configs.py 377:\t Using statistics source all\n", + "07-04-2021:08:45:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "07-04-2021:08:45:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "07-04-2021:08:45:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "07-04-2021:08:45:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "07-04-2021:08:45:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", + "07-04-2021:08:45:14 INFO configs.py 351:\t Found 4496 active trials\n", + "07-04-2021:08:45:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "07-04-2021:08:45:14 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", + "07-04-2021:08:45:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "07-04-2021:08:45:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "07-04-2021:08:45:14 INFO configs.py 806:\t Setting cuda=False\n", + "07-04-2021:08:45:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "07-04-2021:08:45:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "07-04-2021:08:45:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "07-04-2021:08:45:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "07-04-2021:08:45:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "07-04-2021:08:45:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" + ] + } + ], + "source": [ + "all_fori_images, all_fori_acts = [], []\n", + "for key, mask, mask_x, mask_y, param in zip(keys, masks, xs, ys, params):\n", + " fori_values, fori_images, fori_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20, True, True)\n", + " all_fori_images.append(fori_images)\n", + " all_fori_acts.append(fori_acts)" + ] + }, + { + "cell_type": "code", + "execution_count": 291, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([16. , 4.97877036, 1.54925964, 0.482088 , 0.15001284,\n", + " 0.0625 ])" + ] + }, + "execution_count": 291, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(fori_values[::-1] / fori_values)[idxs]" + ] + }, + { + "cell_type": "code", + "execution_count": 330, + "metadata": {}, + "outputs": [], + "source": [ + "i = 3\n", + "images = np.stack(all_fori_images[i]).reshape(20, 20, 36, 64)" + ] + }, + { + "cell_type": "code", + "execution_count": 331, + "metadata": {}, + "outputs": [], + "source": [ + "idxs = [0, 4, 8, 12, 16, 19]" + ] + }, + { + "cell_type": "code", + "execution_count": 332, + "metadata": {}, + "outputs": [], + "source": [ + "plot_images = images[idxs][:, idxs]" + ] + }, + { + "cell_type": "code", + "execution_count": 333, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6, 6, 36, 64)" + ] + }, + "execution_count": 333, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 334, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 334, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(all_fori_acts[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 335, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABC8AAAQwCAYAAADFMXRzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAC6wElEQVR4nOz9Waxe13kf/i/ZGiiOh/MsUiIlarQma7BlS05ix01SZ3SDpIhToAOMoihykaBzAPeqLXrTpnD7k1MgQAe0dtAMnlqP8iBL8qTJliyJlEiK8zyJpChb5v/CKJA/13e76+VLHq5zzudz+eAd1rv3s9deZ4n67svOnj1bAAAAAHr1lks9AAAAAICfxuYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTt8lFePHv27LMTExMXaSgwmj179hw8e/bs0lHfp4/piT5mqjt69Gg5derUZefzXn1ML863j/UwPbGmYDr4aX080ubFxMRE+fCHP3xhRgVj+shHPrL9fN6nj+mJPmaqe/jhh8/7vfqYXpxvH+themJNwXTw0/rY/zYCAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LXLL/UAAOBcl1122SX7nrNnz573543zXma21p5vfZ0+pgeT0UuTdb9gehmlNy90H1/o+X4m8S8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArnnayHlKqbM//vGPm17XmlibEmZba6O+luljlHP8lre07V++9a1vPd/hlDfffLOqjXJdSL2fXi5GwvY486z+4kIZ9/7aes++/PK2pVvrddG6dhnlM5k+RjnnqV9b1wCtn5ektcwo16O18fQ3yjzV2rPpdUlrf6W19tA6fSb/jedfXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12ZEYOc4wZejBKUkreFYyYUOAB167UwJeJnJhnqkNZTohz/8YdPrLkYYo/6c/lqDY4f6+Ec/+lFVe+ONN5pqrX2cQhJba6WMHyjH1DTuXHfFFVdUtauuuqqqpb5La4h0rbTWSmkPqBPiOTWlwMB0zof6I0nvf/3116ta6tc0b6YxputkKGi8NYDc/Dw1pP5KfZN6bmjtkV6ber41xDP1XJqzUx8PrSlSvXUtNdV727+8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICuTbvAztbQzRR0kgJVhkKnzpw5U9VOnTpV1U6fPt303vQ9adxXXnllVUsBL0P19Btbg+SmesDLVDJOGGZ671C4VgolOnnyZFVLfZxCPFMvpXC5q6++uqrNmjUrjjH1fOpjPTu9pF4aCgtMvfjaa69VtTRHp2vjYvRx63ysZy+t1lDsVGtdVwxpDelO/Tm0Dmh5b+q5obVPa+B4IsTz0knnLc2brXPS0aNH4/e0hiKmuTitjVNfpzk21WbPnh3HmNYUreGH5udLK52T1jly7ty5Ve3YsWPxe1Lv7N27t6ql6ypdA60hs629PVRv/RsvmUq97V9eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXpnRgZ2s4Z2vQWqoNhWCl705hcikM7o033rigtaEwxnGCtZJxQiQZNk6IWQrnSWFUqVZKDqlqDRZMUs+Ncw0M1dMxu9D9zmjS8W89J619PDQfz5kzp6ql3k6va53X0hhHCccSKNufcUKQxwmJS71ZSnvo9/Hjx6taul7SeFqv06F1RSKI89Jpnb9Sz6XAzhQ2uGDBgqqW5tJSStm/f39VS72U1sspPDH9lnRNzZs3r6oN3X9SGGMKPxTiOXla59jUn2ldsHPnzqq2ePHiqrZr167WIcaePXz4cFVLvZTem66hUdaxrQ91aF17TKW/8fzLCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2rQL7EzBLSmIM4X7pNcNhaekwKwUVLR3796qlgJeUghN0ho+Wkp7KFEKeGkNKmI0raFEFzqMNvV7KTn4qrVv0nhSKFEKoXvttdeq2okTJ+IY02vT9ZJCwYR4XhypZ9O5P3PmTFVL5ynNN+kamJiYiONJ/T3O/Je+O4Xbtfb2UH2cPhaSOJrW0LI0r6Vg1tY+TqFsad4d+u60Xki1NJ70ea0hzUMhz+m1qWa9MDlaA/XSuiD1YVrHpp657rrr4vecPHmyqr3yyistQ4z3kDRHpvmwNaR0qN4aVN467/YadDiVDAV0nyv18c0331zVDhw4UNUeeuih+JlPPPFEVVuyZElVSz2baqmXWh/ykNYeQ/XWEPGpHiDu7gIAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXZt2gZ0pwDCFuSxevLiqLViwoOnzSsmhPSlYKIUXpeC29LpUSwFxQ2Gfb7zxRlVrDTBsDZZMplLoy1SSgnhSLUkBs6WUsmvXrqqWQo327dtX1Y4ePVrVUoBQa4jdUKhoa7huCphLx0d/ji/NBSlo6vTp01UtzVfpPLWGeJbSPsfPnz+/qg0FHp8rzafpukphikNa59nWuVeI52haQ7+TFEZ75MiRqtYabltKvjbSPLt169aqduzYsaqWfl/q93RdpPXQ0GvTfN46HzOetKZL825ad6Zzme713/72t6vaxo0b43jSPJk+M90vUshy63ekz0u1oXpr8OJUDzrsQZoTUx+n+2taFzz22GNVbdOmTVXt8ccfr2rbt2+PY0w9lubdlStXVrU0F6f5tLWXhvqr9Tim2jiByj30u395AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABdmzKBnSkgJAW3pFoKqGoN/BsK/EmhbDt37qxq27Ztq2p79uypaq3hhynwatasWXGMKfwoBWul96eaoKKLIx3D1gDDdJ7SeR86T63hdCkYKL13KDz2XOlaGxpLChZq7Tshs5dWCopK81oKRkuBiEP9lYK9WoPj0hhbQxbTb0njHnptGuNQmCPjaQ03S8c/vS7ds9MaIL132bJlcYwpIHz//v1Vbe/evVXt4MGDVS3NaykAOfXhkHRvSnN3ul+NM5eTe7h1rZD6NYUI3nTTTU3vPXToUBzj9ddfX9XSvJ2CEtPapXWNktZCo6wpxmGdMb60JkzHNc2dS5YsqWqp5/7gD/6gqn3uc5+L43nXu95V1VIwaAoLX758eVVLD1tI12n6zel1pbT3cWsI+FTqT//yAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC61mVgZ2uQSGuIZwrtSYGd8+fPr2pDYZgpkGX9+vVV7fbbb69qx44da6qlELrXXnutqp08eTKOMQXWDAWQtmgNfUmmUhDMZGvt7dY+XrRoUVOtlFImJiaqWgp0S0FyaYwp+C317JEjR6paCsEdqqfrJV0HKSQxBegxrDVQNvVnmj9bAzJTGNVQYOeBAweqWgrISqGGqb9Onz5d1dJxSNdfCp0rJQd7pdem4LJ0vBlNawhr6/yQ3puCDVO4ZgrhLKWUFStWVLU07nRdtQbepTVS6q9R7tmtYahTPSSuR2meXLp0aVVrDWa///77q9q6deuq2re//e04nlWrVlW1DRs2VLVnn322qqU17zj3kHRNDNXNsRfe0N8H6fyl+3V63SOPPFLVbrjhhqr2mc98pqpt2bKlqqX5uZRSXnrppap26623VrUXXnihaTzpfpHWD8nQcRznIQpTPcTTv7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6dkmfNtL6pIpR3t9aS0/dSEn2Q+n26WkHO3furGrbtm2rajt27Khqhw4dqmopfTcZSlROSbapNmfOnKo29JSVc6Wka4a1pgOn45pel3o7PWEjPfGjlPx0kJS+nK6D9ESG1LPpvWfOnKlqadxD9XT9tiaQkw2lSo/ztJFUS0+uSUncaV5LT0oYen/qz/RkkVdffbWqpdT7JD1BZOjJPosXL65q4zxZy9w7vtbjn57AlGpJugaGnvrV2k/Lli2raulJOukaSONJa4A0llLGe0JOr8n1vRn3KQ1pPkxr1scee6yqvfzyy1UtPS0kva6UUr73ve9VtXvvvbeqLViwoKqle33qzbSOTcdm6MlBreurC20qPc3hYhq6j59r4cKFVS31TeqRf/Wv/lVV+9rXvlbV/v7f//vxuz/5yU9WtfT0yPRkkbSuTnNk6zpj6O/QdB8Z54mSSa9PlLT6AQAAALpm8wIAAADoms0LAAAAoGs2LwAAAICuXdLAzlGk0JAUxpPCSlJ4ylA44LlSEEwpOaxr+fLlVe3GG2+saimk5ejRo1UtBSyl9548eTKOMYV1pWORjmMK20oEEF0c6Zyknk1BPun4nzhxIn5PCvJMgZ3bt2+vart27apqR44cqWrpt6TArYmJiTjGFNqUXpsC5lI4ZGuQnD7+iXQcUuBWCqRK5zmdkzQvpfOUwgJLyQHDqUdS2Feat9N8nMaYjsNQ2HEaezo+6TP14vha+zj155IlS6raqlWrqloKb3vxxRer2r59++IY07pizZo1VS31WFobpDVE6uNklJ5rDXW70K+badI5SffXFIi9dOnSptorr7xS1datW1fVUghnKaV85zvfqWopVPTmm29uGk9a96R5M4WUpuMw9Jmt4Yd6c3ytx/r555+vainA+OMf/3hVe+c731nVnnzyyaqWAmZLKeWmm26qav/9v//3qva+972vqqV1cLpfpPk+HYehv8fS33hpjkjXRjKV/p7zLy8AAACArtm8AAAAALpm8wIAAADoms0LAAAAoGtdBnam0JBUaw3oSYGWKdwqfUd6XSk5KOXgwYNVbefOnVUtBR0eOHCgqqVxpzGm0LFScvBYCjpKQXIpEGwoiI7xpMCtdJ5Tb6cgn9QPKRiolByGuX79+qp2zz33NI0nXReplt47FKLbGu7UehwZXwpxau3FJM3l6Xy+5S15vz2Fc6bwtzTXpe9OPZvm4xREl947VE/hianWGhzXWpvORgkYS69tXWukXlqxYkVVS/fhLVu2xPGknk9hoatXr65q6VpLQc1pTTNuH6f3t87xQjxrQz2c5r+hEONzpfv6bbfdVtWefvrpqrZy5cqq9q53vSt+z9ve9raqltbB119/fVVLvyWtjVtD+EcJKh/q93MJ8Ww31Mepntaoae5MgZ1/8Ad/UNU2b95c1T72sY9Vtf/5P/9nHOOv/dqvNX3m/Pnzq1q6rtLfh1dccUVVS2Gfrb05pPWBF1OJf3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF3rMrAzSYEjKaAnBcGkcJ4UbpXCkIaCDhcsWFDVWsMPU/hKa7BWqqXfN/Q9KeholGA8xtManJNCoZIUJJe+48orr4zvT0GHy5cvr2opJCkFuKbvTkGHR48erWqHDh2KYzx8+HBVO3bsWFVL18Hrr79e1QR7ji8dw1RL/Znm7RT4l87dUKhrCnpLIXOplq6BJPVXCtca6uNUT+9P94LUn61zBMNSf6ZeTLXUi2vXrq1qqY9TrZQ8L6ZQtxTimQJq07yd+jjNp2ksQ69NWucIfVwbuh+1BvKme2YKvrz22murWgqU/8IXvlDVtm3bFse4YcOGqrZnz56qlq69O+64o6qltXZaU4wSpJm+uzUYPL2XbJQ+Tj2bQsA/85nPVLWbbrqpqn35y1+uaimMduj+/4/+0T+qar/1W79V1Z555pmqlsJsW6/dtJYZmiPTuj79jZf+npvqa15/oQIAAABds3kBAAAAdM3mBQAAANA1mxcAAABA17oM7GwNNRwndCeFbaWAyxRKODTGFCKUQtr2799f1VJwWwoJS8chhY+WUspVV11V1a6++uqmWgqNSeE5DGsN6En9mUJ3Ui2F+6WgtRTWVUopL7/8ctMYU8Bc6vd0DaXrNAUIDYWKpmsw1VKwXWswb5LCf6ezoQCn1rk39WeS+iaFdQ0FBibptel7UthgCjpMc2f6fSn8MIUql5Kv1XRdjRI8R22UY5X6uDWYNQUb7t69u6rNnz+/qh08eDCOJ83TaTyt9/HFixdXtTTPplqaT0vJ64A0V860+XMytIarp/vjzp07q1o6x6tXr65qW7durWrf/va34xjT+1NwfZqL05y9atWqqpbu6+k6GQp4Tr97nL42P48mnb/0N0d6YMIv/MIvVLXUNx/96Eer2ic/+cmq9ru/+7txjN/4xjeqWgoGve+++6pa6u0UFr53796qltYZQ3185syZqjZT5mf/8gIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAutZlYGeSgopSiEkKO0shgikoLYWfTExMxPGkIJkVK1ZUtbVr11a1FO6TvjuF0KRQovS6UvLvTmEwaTwp9CUFQ0310JfJ1hpG2xoO2BqSOBTqms5pa3+mQNl0XaXPSwFxc+bMiWNs7c+h39hCHw9rDZlNfZxqqW9aw46HwjC3b99e1TZv3lzVlixZUtUWLFhQ1cYJdBsKNk71Cz3PCo4bTTrW6dynPk4hninoNYUnDq0r0vyZaiksNPVxWiOl35zuLalWSl5XtK7FUkAqtaHrPZ27dN9L686FCxc2vffd7353VXvggQeq2re+9a04xhTYeffdd1e1FG6beiYF3qbrrHXtX0p7aPeFZp3xE60PVnjhhReq2qJFi6paCtd8/vnnq1oK0vx7f+/vxTF+4AMfqGr/4T/8h6r2N//m36xqae5sXcemNf3QmqI1iHM69p1/eQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXZsygZ0p7CSFP6VwqxSAkgJ7Uhjc4cOH43hS4GAK9UqBQa2hmykkMUkBY6XkoLDZs2dXtauvvrrpvUOhMbRrDexM4UWpj1P4YZLOeymlLF26tKqtWrWqqqUQrvTe1EvpN6dxD4UxppCldA2la601WJLRtIZztgZItgbHDoUIpvrOnTurWporUy0FwqVaCplNwYml5MC8FEaXrtU0xksVOjdVpdCydFxTIFwKNkw9l4I4U5D3smXL4hhT0OKOHTuqWlobpNelOTH9lrRuGrq3tIadpxDPdE231maSod+f6q0h2el8bNmypart2bOnqt12221Vbd++fXGMn/jEJ6paurendUYKwU09nALz0/ooHZtS8rFIf0+Mc09jtODZdN9bv359VUt/h/zDf/gPq9pTTz1V1X7v936vqn3uc5+LY0whtffdd19VS31zzz33VLW0Hpk7d25VS308FDw7ThBn63t7DQC1+gEAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArk2ZwM5knBDP9LoU3pVeV0oOvUrha2vWrKlqKQwzScEtKRhrKMwlvTYFGCYpFCeF7PQa5tKrcY5XCo9KwVOpb1Jt6DNbv+fEiRNVLYUupd+X+nAoXCv1d+rtdK0K15o86TynOSOFuqYwy1HmrzRfpfen8aTw5TRHp3GnwM70ulJy4Ge656TfYk4dXzqG6Vin85TmtRRomc5n6qUUCvrT6ud6+eWXq9quXbuq2v79+6taGmNrkPTQa1vDY9M5MEePJ52nFACf+jr15vPPP1/V0no3hdOWUsq2bduq2qOPPlrVHnrooaqW+iP1dQpFTvf/odDZtKZIaxzh3uMZJXg29Wzqh9Rfu3fvrmrbt2+vav/8n//zqnbLLbfEMabX/s7v/E7T96T+Stff0aNHq1o6NkN/46X10ExZB/uXFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNe6fNpI6xMZUsJ1a+p1evpCetrBUFpxSolNyeVJSjBuTYhN35HS8kvJqfeplhKnJd5fHK2J9+mcprTi1LPpKQuvvfZaHM+xY8eq2o4dO+Jrz5X6M/2+lG6fntIwb968+D0p1Ty9Px2f1qfmMJrWOTql1Lc+ySM94WEo4f748eNVLSVxp+9OyfWpv9J7R+ml1sTvC/06fqL16WSpb1Ifp3Of5tmtW7c2fUcp+YllKWk+9fvOnTubvqf1qRPpdUOvTferNO+be9sMrbVSPZ2n1Oupt9auXVvV0pMb0lx89913xzHedNNNVS09ISLdm5csWVLV0hNzjhw5UtVan7pSynhPG2mdd62Xx+/jNF/ceeedVS2tYz/0oQ9VtSeffLKqvfOd74xjvPnmm6taWqf8yq/8SlVL19CyZcuq2r59+6pa6sOh+8WFfkLOVOpZdxIAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6NolDewcJRwkhfukQKgU+pLCOVNQVwo/GQqYSgFVKXAw1ebOndv0eUkaY/otpeSQl9aQxfS7W0P6+InWY5N6O/VxChFsDXVNfVNKe3DSOOGv6TpNYxwKvG3tz9b3Mr5xQpVTP6RamieHAjtTcG26NlpDQNO8nUIb071lKBw3hcelcV/oEC5+ojWwMwUep/Ocaik4bu/evVUtBbWVUsqiRYuqWjr36XtOnDhR1VIwYZq3U7+PsvZhcrSGRaa+Pnz4cFVLPZz6bfPmzVVtKAxzxYoVVS0FbH7zm9+sauvXr69q6TcPffe5hubN1t8tnPPiSMc11dL8le6Zqb+++MUvVrU0dz388MNxjPfee29Ve+mll6raPffcU9VSLx06dKiqpbk49fbQ+j0di9aHP7T2bK+97V9eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXLmlg5yhag99ag2BSOGAK6hoKw0z1FJiVwldawzBTQFyqDQVopXrrZwrnnDytvZ0CO1Mfp9DMoT5O70+hhgsWLKhqKegwjTH9vhQmm8KHhuoXOnCL0bQe13ROUi+2zkupN0vJc13r96QxpqCwNP+lIK2hPm4Njtazl1ZrOGrqh9SHaV0xFOqavjsFKKfvSfNxa4ByCsdNYXJD42ldQzCedEzTfJHuuWmuOn78eFVL/ZH6bceOHXGMrcH3KWRxy5YtVS2tPdL6IV07QyHg49DX42v9+yLNX6nfU9Br+nsshckuW7YsjjHNiQ8++GBVS+HJq1evrmopMDdJ64d0Dynlwod7T6Xe9i8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrXQZ2toaGpDCeFCzUGoiYQoBSbegzU2hV+p7WWvqOZCjgLdVbj+1UCm6ZSlqPa+ql1A/pGkiBakN93Bpwm0KJUhhtGk+qtYbWDtX159SQAilbw1ZHCQFM709hVqlnU28nqWdHCcdqvdYEdvYn9V2a11LIW1qTpN4sJfdYen8K00xhyelaS9L6YyjsML3WHH3ptB77tC5Ic03qtxRAeOrUqTieNG+n3kzjSUHJQ2uXFkPzs37tzzgh4CkAOb1u27ZtVW0oBHzr1q1VbfHixVUtBWymPk7z5tGjR6taugcMBe63HrPp2Nv+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdK3LwM5knBDP1nDNFIoyFPgzTlBK+swUrJXem37LULCncM6pofX4twbPpt4e6uPWwMFxQgTTd4zSc/pzamjtkRTA1jonDs116f1pPGmOT7XWsOPWOXrotUwvaf0xa9asqpZCEYe03vPTvSAFe87kkDf+39K827quLiWH0Z44caKqtc6daX5uDfwWAj51jPM3XprT0nyY5t2hYOKlS5dWtbTOmD9/flVL11DrOiOtj4R41/zLCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2pQJ7ExaQ3dS2EkK/GkNghnFOMFAAoT4q8bppaFwrXG+e5zXJUKJpp/Wc9oaHNv6ulG+e5x5X/DbzHCh56ah+Xic66U1ALH1O8zH01/rejmFDQ7Nc+P03FB4Ygsh4DNX64MR0utSQGYpuY/TZ545c6ZliPF79OH58y8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrUzqws9XFCBu80GFWglu4mCarv4S8cT4mq2+EJXMxXYw+HidgszWQEf6vcee+ccLBzbtcKBcjzH7c4HsuHGcCAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALo2IwI7LwbBQgBAr4RzAjDd+JcXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LXLzp492/7iyy47UErZfvGGAyNZd/bs2aWjvkkf0xl9zFR3Xj1cij6mK+ZipgN9zHQw2McjbV4AAAAATDb/2wgAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQtctHefHs2bPPTkxMXKShwGj27Nlz8OzZs0tHfZ8+pif6mKnu6NGj5dSpU5edz3v1Mb043z7Ww/TEmoLp4Kf18UibFxMTE+XDH/7whRkVjOkjH/nI9vN5nz6mJ/qYqe7hhx8+7/fqY3pxvn2sh+mJNQXTwU/rY//bCAAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXLr/UA5iqzp49e9G/47LLLrvo3wEATJ6LcW+fjDUJnI/W3rTmZbJdynlTv58///ICAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADomqeN/BU//vGPq9pQEu1b3lLv+6TXps9M703S542bTivddnpJPZL6a+i8p/e/+eabTd+dPlN/8f8yTo8Mzcep3jp/to4nvc4THvirWvtr3Hmyte/0JxdC6/z60+otLvS1Yj0yM7T23Ch/441jstbGM7m//csLAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOjajA3s/NGPftT0ussvz4fozJkzVS0FHV511VVV7Yc//GHTd7/1rW+taqMEtAg6mrpaQ4RSf6bAzqF+P336dNN3z5o1q+m7xwkAHaIXp67W4KrWsOM33ngjfk9rMPIVV1xR1Vrn2XGDvYQnTl3jBHG2ztFD0vyZavqLUbXOu6k2dF9vDUVM10Cqtc7PAhFnhnF6Nq2Dh/q4NfB7MvpYb9f8ywsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6Nq0C+xMISsp5C2FaKUwt0OHDsXvSWEnExMTVe3YsWNVLQXEzJkzp6q1BnsOhX9d6KCjqR7w0qvWYKDUn+ncnzp1qqodPHgwfnf6zOXLl1e1uXPnVrXXX3+9qp04caKqpX5P11/q1yGtx4zJM044Z5rrTp48WdWGAjtT78ybN6+qzZ49u6qlayCFfaUxpgAwwYlTW2soW+q5K6+8sqql/hqaq1oD5dLrUi31cRp3+n1DYzTP9i/NQa1Bh2meSwH1qVZK7sPUM6kPU8B9un5a1w+jBOO23qv0/+QZJ4gz9Wdasw6F2beGgLfO+a1h4aM8qGGcwM+p3tv+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdG1KB3amwJEUvjJr1qymz9u5c2dVmz9/fnzt4sWLq9pLL71U1VL4yooVK6paCvZMgTEp2DMFeg29PwXOpPCjVlMp4KVX6ZykcJ/k8OHDVW3Pnj1VbcGCBfH9N910U1VLvb1r166qlq6X1HPpGkohR0OGApXONdUDiKaScUKhUmjW0aNHq1oKnh26LtKcumrVqqqWQjzT/Hn8+PGqlsJC03uHAjvHCUvm4mg9J63hgldffXVVS/fXoTDu1PMpBDmF2aZeHCdUdOhaG6ePhdlOjnScU3+kUMPXXnutqqX1aZrHh74n9WFal6f1bQpZbjVK0GHr+sE64+JIa8fWPk7zYerjNL8OBc+mc5rm/NTHqZZ+S+s6eKi/WoOWW183lXrbv7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK5NmcDO1qCnFO6Tgtb2799f1datW1fVUtBQKaU88cQTVW3lypVVbe3atVXtueeeq2opHGv58uVVLYXQDEnhYUkKRBTieXG0humkc5LCOQ8cOFDVVq9eXdXuv//+OJ6FCxdWtW9+85tVLfV76tkbb7yxqqUwxdOnT1e1FJJYSg63S/2ZjuNUCiDq1TgBfSnULZ3nNK+lcKxrrrkmfk/qu2XLllW1dC/YvXt3VUshiSlUNIWMDQUdpnCu1LOthB+OprVnW/s91VKYXJrLUwBiKaUcPHiwqZaC51IvpQDEFFo7SpD3OGG9ra8jS8dqnOOX5ue0zjh06FBVS/fwUvKcmAIM586dW9XSejvNp6MEfo9DiOfF0dqzae3XGh6b7vWtQdyl5L5rDaNNa5ek9Xoe6qXWhzK0vm4q9ax/eQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXZsygZ0pFCWF9qSAlxRWcuedd1a1FEr07W9/O47nnnvuqWop4OXLX/5yVUuhc6tWrapqmzdvrmrpNy9atCiO8cyZM1WtNVxmOga89CAdr3SsU2BgOp9ve9vbqtrdd99d1YZCBD/5yU9Wta9+9atVbenSpVXtPe95T1W77rrrqloKREyBuUMBYK3BXsm4gUgzydAxGCegrzWYK81hKez4lltuie9PIbXpekm9uGXLlqq2c+fOqpaCF1NvTkxMxDGmAMTWvktzhPDDbJQ+TtIxTOc+vS7NYSmMNs1/peT+PHLkSNN4UhBn+s0p1HyUwM5Ub+1PfTye1jk2rYNbQ4hb141DhgIQz5UC5VMvpH5LtbTGGWXcqTcZzyjXcQrDTLUUQnzy5MmqtmvXrqqWrov58+e3DjH+/ZXCaFv7s7VnRzmOrX+7jTPH9rBe9i8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrXQZ2pnCR1mCTFOaSwgb37t1b1VJ40W/+5m/GMW7durWqfelLX6pqDzzwQFVLYSePPfZYVUuBdSnYbs+ePXGMKYgzHZ8U/jVOSF/SQ8BLD1KYTgolSiFA1157bVXbuHFjVTt16lRVS8GcpZTyne98p6pt2rSpqv3O7/xOVUv9mQJun3jiiar2+uuvV7V169bFMaYAxHQc02cK5xxfa4haOtapj1NQ25IlS6paCn9duXJlHGPq+R/84AdV7Vvf+lZVS4GdKXQu3UdSbSgALM3H6dpPoWLjhKEyLPV2Wle0hq2m4LiDBw9WtW3btsXxpKDY1NvpGkpBnGndlEJmU9hnunaHpDVEa8ipPm6Xzmc6fikk9vDhw1Xt+PHjTd+b5qR0fkvJfbNgwYKqltayqTdTX6daClMcuten9UP6PWl+bu1Xa4/Rjn+a51K/p7Dj1MdpHZted+DAgTjGdL9O82TqxdY+bjXUc60hp9MxuN6/vAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArnUZ2JlCQ1JwSwpGW7x4cVU7c+ZMVVu2bFlVu/vuu6vak08+GceYgrX+9t/+21XthRdeqGpf+9rXqto73vGOqpYCVZ599tmqtmLFijjGFC6TgpxSME1rIB/DWgNxUtBUCqlMPZvCi1IoYQqNK6WUX/7lX65qv/3bv13VUgjXX/7lX1a1T33qU1UtBeClfh8K7EwheClkKYWKtQbtMf5xSe9PwYIpzGr58uVVLfXcULjWSy+9VNW++c1vVrXnn3++qp0+fbqqrV69uqqtWbOmqqVQ0aHAztSfKUBMYOd4ho5LColLc1Pqu4ULF1a1NLekeXbXrl1VLc1ppeTQujTudF2lAMS0Nkiht6ln0+8rJYfZpmsonYf0W/RxuxTGl4Im0xx78803N31eCjrevn176xBjf6X5Pa1xUh+mWur/dC2n31dK7uHW2jghnjPN0PFP80AK7U5/u6XPXL9+fVV78cUXq1oKrb333nvjGNPfRa3XWurZtM5PPZseWJGOw1A99exkhCdP9rrav7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6dkmfNjKUTprSVlNS65w5c5pel57SsGDBgqq2efPmqpYScEsp5f77769qn//856va1q1bq9qHPvShqpZS8NOTTu66666qNpTo++qrr1a19DSW9CSXlFibzkuqzbSnOYyS0JuOTUo1Tn189OjRqpbS7VPq/Lve9a44nve85z1VLT0B4b/8l/9S1f78z/+8qqWk8fREkxtuuKGqpX4tpZRXXnmlqqX+TE/XaX1qTuuTYaazlAA+pDW9Os0tab5KTyvYt29fVRt62shzzz1X1VJCfvqN1157bVW78847q9qtt95a1dJ8mn5LKfnJQKmPh5LFz5XmXob7uPVpREl6XWt6fHpvmqtKaX/qTnryTerjlMK/dOnSqtaarF9KfmJZuqZTb7dKc+9MeqLDUA+nuSXV0hMQ0lx14sSJqpaeAnLPPfdUtdmzZ8cxpnOXeiG9Lj2lIV0T6bvTMRvqwfRUn/QEoPSZnpiTpWMwNL+m16b1X+rt9FS6NP+kv90efPDBqvbyyy/HMaa/3R544IGqltbb6XenJ+S0XivpXlNKXl8NPcnqXEPz+1Rh9QMAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbukgZ1DUohJqqVwrBT4k8I5UyhaChFMYVmllPL1r3+9qqVApHe/+91V7VOf+lRV27FjR1X71V/91ar24osvVrWhwJn0e1JQzrFjx6raUKBYy+eNG2A5XbQem1RL/ZlCgFKYVQo02rhxYxzjzp07q9onP/nJqvbII49Utfvuu6+qffCDH2waz6OPPlrVvvzlL8cxpgCj9JkpOCmF9KUaw9dtCnZ6/fXXq1rq2TRHp/PZGhCcQmtLyYFdq1atqmopxOu2226raimcM703hdsePnw4jjEFdh46dKiqpfOQArtSbTrPp+NK/ZSOdQo8S72dQv9SgPKRI0eqWlqTlJKDOFMfr127tul1aU2S1jTpGk9hjqXkY3GhAzZnegDiUBhvCqlPAZsp6PCrX/1qVUvrzhTy+s53vrPpe0tpDyZO70+B3yl8tDWseCiwM92XUhBnui5aw6oFgw8/TCD153XXXVfV0t9zqY9TiHCaI1MoaAorLqWU3/md36lqaf2xZ8+eqnbLLbdUtdTHSeqHoRDO9LfbOCGzQ+erR/7lBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB07ZIGdg6FMqV6a+BIel0KIUnhaykEaPv27XGMKZAlBb+kcM4UVJSCPT/zmc9UtRQIlt5bSh57ev/q1aurWjoWKeiwNThpJmoNbEoBUKmPr7766qqWAjtT2OrWrVvjGJ966qmqlnrkb/yNv1HV3v/+91e1FEr0iU98oqql62Kol1JY2LXXXlvVUnhRCnJK80EK8JrOQVrJuIGd6Vinz0whauk7Zs+eXdWuuOKKOMZrrrmmqqUA1w0bNlS1FGy8cOHCqpaCOFPg3XPPPRfHmMLCUi+mkLIUsjjO3DudAxHTtVzKcO+cKwVSvvLKK1Utnc8Uzpn6OIUilpJ7cdOmTVUtBXumfk9rktZwznQ9l5LXAemYpes8vbc1oH26GuVaTOcz9VdaP6QAw9RHaX2aguJT2HcpOXQzhXvffvvtVS2FEKd7TesxS31ZSj4+KUQyhaSneXcqBR1eLKOE9qb7WZo7U4j7O97xjqp21113VbW0xkz3hqGHE6Rg0GXLllW19773vVUt3WsOHDhQ1VKgcmsgbCntxzx9ZurZdF30yl+eAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1SxrYOSSFhqTAkRTGk0J3UgBaem9ryNHQ93z3u9+tanfccUdVS6FL/+t//a+qlsIP77///qr2yCOPxDGmoKMbb7yxqh09erTpvQsWLIjfQ7txwmiT1Md79uypailssJQcSJWCOG+99daqlnrkP/2n/1TVPv/5z1e1FIj4q7/6q3GMKWQxhdGmALEUEJeuK8Gzw8YJ1Gudy1MtGQrXSiFzKYg4zecp8G7v3r1V7ZlnnqlqTzzxRFVL4Xal5N+YgqNTMG9rYGcK4ZrO4ZypD4eu5RSilgLc0pzRGlqbpPM5dC+dM2dOVUtjbF0PpeOTeqQ1gLeUHIycaqdOnWoaT7oHzaQA5VGCDk+ePFnV0lyVPvOmm26qanfeeWdVS/fWtMZMfV1KnqPTfSDNk+nevGrVqqq2YsWKpu9I4eOl5IDaNG/M9DDZUaSeHeVYpWv+Z37mZ6pamuf+wT/4B1UtBWn+wi/8QlX7+te/HseT1rwpFPnRRx+takuXLq1qKbQ2rT3SWj0F2Q5Jc0R6fwpUnkohnlbsAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1SxrYORRKlAJCUohWCoRKQTwprCQFXqWwoOPHj8cxplCVTZs2VbUUhpkCXlJwUgpz+cu//Muqtnjx4jjGFBb67LPPVrUUqrNy5cqq1ho2mYJ3ZqLWsKJ0XFv7vTWMbyjELgUYpn564YUXqtqXvvSlqvbkk09WtRQS+8EPfrCqpWCuUnIQ7je+8Y2qlo5FCm1MgbnjhKZOF0P9mq7nFCCZpACodPxTaF/q2aFzkr4nBQ6++uqrVS0Fx7388stV7amnnqpqL730UlVL124pub9Tbfny5VUtHZ8UsqiPR+uR9NrU7ykgMIW3pd5O4ZxDYYdpjJs3b65q27Zta/qeNMZ07aYA8hQEWUop+/btq2ppPZTWWOm707wz09cQowQdpvVten8K8k7rwTRvprDPD33oQ3E8KXQ2rQvS3JnWHincO62F0rw7NBen/moN7Z5pocitUs8NhT2m85KOf+rZdPz/5b/8l1Ut3TP/2T/7Z1XtbW97Wxxjqn/nO9+paj/3cz9X1a677rqqltYZaT5Mf3sNSfN2+ju2NTx5KgXU+pcXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1SxrYOWScwM4U0pKkz0tBRUOuuOKKqpYCrnbt2lXVbrvttqqWAq8+//nPV7UUwpkCkkop5atf/WpVW7p0aVVLoYYpaDT95tawqF5DXy6m9JtbQ09b+z29LoVRpSC5Uko5duxYVUs9m0LjUpjSPffcU9Xe+973VrUUWPe5z30ujjEFg86bN6+qpYClFPaVQo5SuFwynft46Le1hmmmc5pel/oz1dJ1kQKZS8l9vH379qqWQi4PHDhQ1VIgYur3ZP369bF+6623VrWNGzdWtXStpt+d+nimBXam3zZKEHh6bboOUohqClZLAawplO3gwYNxjFu2bKlqKWQ23QvSnLhs2bKqltYLZ86cqWrpuhiqp+sq9XFaQ1Ab6uF0/ObPn1/V0ros9VEKJk5zcTq/Tz/9dBxjCrlP47n33nurWgoGTevydJ2kMQ79PZCOb7oGUm2cOXY6rx9Guc+khxGk85eOVwp1/dSnPtX0ef/4H//jqpb+/imllP/8n/9zVUvBzWk+/PrXv17V/tpf+2tVLf0tmNba6beUkntxKCT1XGltNpX607+8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICudRnYmbz55ptVLQWWJSmM7+TJk1UtBUyl8KJSSnnjjTeqWgpVScE0KQxux44dVe3tb397VTty5EhV+8IXvhDHmALi5s6d2zSeBQsWVLUUyMdoWgNxUs+mIJ6hIJ9W6f0prDVdL9dcc01Vu+GGG6pa6u1vfetbVe073/lOHOPatWur2gMPPFDVUhjt/v37q1qaN9J5SYFGM1E6DikIrTXQN703ze8pqC0Fc5ZSyqFDh6pamivT61JYcgrITPeH6667rqrdfffdcYwpnCuF7aXrL12nKax3Oodzjqs13Kw1ZDYFcbaG1g6FqqXzl74njSfd29PnpWsgzZMpgLyUfG2ka3/JkiVVrTWsdyoFx02mdD5TeGs6R6k/PvCBD1S1NWvWVLUXXnihqv3pn/5pHGOaT++///6qltYKu3fvrmpDc/65JiYmqloK3Cwlhy+3BtG2hvzOtB4e5fem85LuZykUOd3X0334lltuqWqf+MQnqloKqC+llN/93d+taps2bapqKbh23bp1VS2tZz72sY9Vtdtvv72qbdiwIY4x/e2W/jZNf0+kNddUWj9YnQMAAABds3kBAAAAdM3mBQAAANA1mxcAAABA17oM7EyhIa21FF6UAkxSaFwK1hoKMEmBW+m1KTgpjTGFW23evLmqpRCte+65J44xfc9zzz1X1VLwYgoaTYE66TjONENBRa3hN629nQJ2Uq01TLaUHCKU3p+CF9Prnnnmmaq2devWqpYCszZu3BjH+K53vauqpetl+/btVS2Fh6WAuPT7GM04wZ6tYV+p50rJ82xrOGeaJ9P8l4LsUijY9ddfH8eYwjnTdx88eLCqpd+Xrn3BccNaQ3nT69L8mYLe9u3b1/TeFIBcSp73U2jdsmXLqtq8efOqWuqvFPKWXpeC8UrJ1+DChQurWgoaTfPsUCj6TDbKmiKdj7RWS4HDqf937txZ1VLA4oMPPhjHuGrVqqbv/uIXv1jV0loh9X9aE6Q5O/V1KXk+TddpCjpMWkNnzcU/kY5XCjtO98Ljx49XtfQ3TAqFv/HGG6vaP/2n/zSO8U/+5E+q2n/7b/+tqv3yL/9yVUu/L827af0wZ86cqjb0UIZ0XaXjmOaD1r9hkx762L+8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAujalHxWR0lJTLaUxp1TV9N6htOFUT2nFKRE+JTynp4ik8aRU3R07dsQxpkTzDRs2xNee6/Tp01UtpYe3prUzmnH6MyWDD6Vup55N10t6f3qaQ0qCTmO84YYbqtrb3va2OMaU3Pz973+/qqUE8ZS8nBLv9ez40lyXUq5bezsZerpROs8LFixofv+50pNBVq9e3VQb6qX9+/dXtXQNHT16tKqla6j1iVn8xDhPG0lzYprrUi2dzyHpKSLLly9vet3cuXOrWnq6TkqoT/f29ASRIRMTE1UtXX+tT7xIWpPwZ5p0P0vHOXnxxRerWpqn0hMQ7rvvvviZ1157bVVLT+ZJTwfZtGlTVVuxYkXT56UnnaX7Tyn5fpGOWVp7eMrT+FrXAKnv0lyT5th0ntJ9/d//+38fx5i+++GHH65qn//856vaZz/72ar29re/vaql+0W6ntMTfErJc+err75a1dI6v/Uph72y0gEAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArnUZ2JmCblqDRFpDPFMAWgr3SeGHpeQAr1RL35Nel35zCtFK4ZxXXHFFHGMK90zBLUkK/xIGN5px+nicsKfWYLqfVj9XujZSH6ewodYQuhReVEopu3fvrmrpupo3b15VS6FgyVQKKpps44THpvcOhai1vDfNiaWUsmTJkqqW+iGNO82fKawrBRCm9w4FNL722mtNtTRG4ZyXVmu4WTp3KfQv1YbqqUfSOiDN+2lOPXLkSFVL8+TatWvjGNMcn67LdG203hPNxxdeOqZpnkuBmyng8uWXX47f8+ijj1a1NOffeOONVe2uu+6qammdsXnz5qbvGOqjdJ2mkPrUr2kuFtiZjXIMWsNR03yY5q9FixZVtTQfXnfddXE8KRj0X//rf900xr/1t/5WVdu5c2dVS+Gaa9asqWovvfRSHGP67jQXp2Obrquk1z62+gEAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArl3SwM6hIJAUstMaGpJCzFI4T3rdKEGH4wT0tAb+pECVFEyTgulKyeGcV111VdNntv6WXsNcejVOiGfqxdRLKVBt6DtaA6laPzO9N4V9pXCtoSDHFDaUwhPT9yTC4MbXGlY4zrFOn5f6sJQcDpiul9RL6TNbPy8FZg2FIreGJafvTuM2914crT2b+iaFxKXgtzRPlpLP/alTp6paCt08efJkVWsNB09z59C6Iq0h0mema8PcO57W9UPrXNy6HkzvTQGXpeQQ0PQ9aYyPPfZYVUvzZgolXLVqVVUbCsY9ceJEVUvh/K1/E5iLL450XNPDBFIv7dmzp6ql3ky1UnLw9h133FHV0jz5hS98oaodO3asqt19991VLfVhCkMvJV+r6XoZ52/gXvmXFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQtUsa2DmkNZRonIDMFICSAriGAjtTEFAK20qhVSk8ZZzvGAolSiFJ6Te2ho9OpTCXqWScfk/9OUofp35KIUCt4Wvpe1qDgYZC7FoDFYXBXVrp+F/oczI0B6XeSfNiel1rgHKat1PIbLpWSsnXQepjc+/kGac/W/srvW7onp3Gk0I3U9+1hrK1XgNDY2xdv7TOB+bt8YwTrp6O/WuvvVbV0jlPc1cppaxbt66qpXt4+p7WsMEkBYgOvTf97ta1cWJ+Hs04a97WMNolS5Y0jSUFaZaS+yHNuzt27KhqK1eurGobNmyoail4OQU0z58/P44xhXumYzE0l09l/uUFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHSty8DOZJxAnPTeFDbUGng1yvtbw2WS1qDDoTCW1iA6AXH9aT3+rT0ySh+n/mwNzWqVenZojHqR/5fUs0PBmef7utbvGJrfzbPTS+t9vHVdMIoUxj0UoHiu1nvG0O8bZ03D5GidVy70WrSUHCKYgjjTd09MTDR9d3pvClMc+n2tv8f8PHkudPBseihDet28efPi96QeSb2d3p/WBYcOHapqKRR00aJFTZ9XSp6LZ0rP+pcXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1KRPY2WqcsJJRQgSTFAYzTpDVOAE2Q/WZEuYyU7Se46kQqKY3OV+tc++Fvg6mwnXF5Bk37HicAMWh4O7zNTQWPT99XIw1Ymuga+s6pfXzLnT/M3WM08dD81kK/EwPQUhzcerZWbNmNY0nBc8O/ZZR/j6dbmbuLwcAAACmBJsXAAAAQNdsXgAAAABds3kBAAAAdG3aBXa2GjcMM5mMICuhhpwPfcN01jr3Chtksk1Wz+ltenChQ0D1NRfTKA88SFrDaFvN5BDOUThKAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1GRvYeTEIRQQAAIALz7+8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK5ddvbs2fYXX3bZgVLK9os3HBjJurNnzy4d9U36mM7oY6a68+rhUvQxXTEXMx3oY6aDwT4eafMCAAAAYLL530YAAACArtm8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrl4/y4tmzZ5+dmJi4SEOB0ezZs+fg2bNnl476Pn1MT/QxU93Ro0fLqVOnLjuf9+pjenG+fayH6Yk1BdPBT+vjkTYvJiYmyoc//OELMyoY00c+8pHt5/M+fUxP9DFT3cMPP3ze79XH9OJ8+1gP0xNrCqaDn9bH/rcRAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK5dfqkHMN2dPXu26XWXXXbZRR4JAAAATE3+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1Txv5K1qfDHIx3p/eezGeQOKpJgAATIZx1sbWrFxM4/7ddynN5GvDv7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK7NiMDO1kCW9Lqh947zma1SGEtrbVwzOQhmOhqlD1vPfetn6iXOx7h901tI3FQOBqN/kzXP6uPp7WIE14/Tm73N4/TnYvw9NhnzXGt/Dr1uJq/B/csLAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOjalA7sbA0r+fGPf9z0uh/96EdV7S1vyfs7P/zhD6vaW9/61qbXXX55fdjffPPNptel35y+t5QLH/g5HUNfppJ07lN/pvOU+nDIlVdeWdXSNZSul9SLaYyp34fou+mlNdAt9c3QfNzan+l1rd+TxjhKyDNTw4Web1LPjRsE3tqfQ9dLi4sR3Mil0zpXXYw5bZy16KUMT7b2uLTG+RuvtY9b/z4c0jrHXozQ2gvdn1Op3/3LCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2pQJ7BwnuKW11hrCWUopr7/+elW76qqrqtrp06er2tVXX930eel1KYQuBSwOSSGg4wR9TaWAl16lY5gCLdM1kHouvTf1VymlzJo1q6qlvjt+/HhVO3PmTFWbN29eVUs998Ybb1S1oV5qDa5tDYJkfK3hla1BWldccUVVS709NC+leTb1WLo20jWQxpO+O83HqVZKe3+29qxAxPFd6NDA1O+p54YClFsDZVN/pnmy9X6femmojxO92JfWubg11HiUUMPWAOTWOfZihM62/h5risnT2rOtc+woQclJ699F6XvS340XI4y2tT8v9Ot64F9eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXpkxgZ2uQVQoRTMFAp06danrdyZMn43hSiEkKjUtBMilILgV4pbCt9PuGAo3Sd7eGr6Rj0arXgJcetIZPpfOcglnnzp1b1Q4ePFjVUuBmKaUsWrSoqs2ZM6eq7dmzp6qlnl2xYkVVS6FgrYG3peReTNdQa3ASo2m9nlvnunQNpKDXBQsWNH1HKaWcOHGiqg31/LlSYOfs2bOrWhp3uo8MheO29mdr2FciOHFYa2Ba6zlpDf1Oa4hReqQ1uDatF1L4cvotaY5O1+5QvTUcz9rgwhsnJDatM9L5Tedy6N6a1imtPdwaRNsaNjh0v2gNKk309fhawzlTz7bWhs79uYb6ONVTH7cGJU9W8GxrmP1U519eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXLmlg51CISAq/SQE7KWgthWMtW7asqh0+fLiqXXfddVVt165dcYzr16+vaq+++mpVSwGGhw4dqmopsC79lhSGlEKXhqRgm9bQstbX8ROtIVfpnKSwwbVr11a1hQsXVrUXX3yx6fNKKWX58uVVLYUA7d+/v6qlsM/FixdXtd27dzeNZ9WqVXGMKXQuBSWmgKYUnJRMx0CjUQ2FjrWGo6WgtzSHpZDZiYmJqrZkyZKqduTIkTjG1E8HDhyoaimMNvVdGk/6zakPU3BzKbk/03haw5L17GhSH6f5IYWypXk73XdTEOfRo0erWgqYHRpjCq5N64UUMjt//vyq1vpbhsLK01os3cNaQ9Zbg1RpDzpsPZ+pNhTUeq6hgO00v7deU+le3xr2mY5N6stS8m9sDdJvDUTUw6MFTaZjne6lo4Rkn6u154Zem2qtAbWtIZ7jBs+2zsVTPaDWv7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK5d0sDOISlIZJygohSAlgKzUtBQCtsqJYcVPv3001XtlltuqWqbN2+uauvWratqzz33XFXbuHFjVRsKFU1BpSnsJoXGpSCYFDjTGhrXQ8DLxTJK8GzqxRQ2mIK0UrhmChtKwbEp9K2UHDyb+i6FbqaA29Rz6fPSb7755pvjGFP4UWuYberZ1Nu9hhL1oDVA+bXXXqtq6TyluTP1dgqjPXjwYBxjCudMtdRLKZwz9XH6fSnk7dixY3GM6TimuTeNsTUgdSjYayYZJXg2zRkp+DK9N4XJpXVF6sOhdUUKIU+1NK+lEM90raWQuHSdDoUdpt+Y1l1pfZbGne6J5t6sNegwnc8UUp/uw+nzUs+kMNhScr+m85mus7ROae3/1r8HShkOoz1Xmk+netDhZBpaG6f1QwrdTP2Z7sPpvaln07013QOG3p96Nq3B09+SrQGgowR2pjVAOhap1hrs2Sv/8gIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAujZpgZ2jhNekMJcU6pTCJ1OgSgrnSeFWKcAkhQWVksNcUohQCnNJ35PGk8adAo1+8IMfxDFu2LChqu3du7eqpcC6dGzTGIUSDYcSpX5Ix+bIkSNVLQX5rFmzpqqlsNY9e/ZUtaEwzBUrVlS1L33pS1UthSSlsM8UQJjCPlMA0erVq+MYU0jjoUOHmt6frt8UOKePR/u9KSgqHdc016WgtxSQma6BoTDMNK+lsK/UD+kaSONJ4W/pO4ZCRdO1ke5rKewrHe9UY1iaj1OAW7pnpzVJOv4piHP//v1VLfVNKfn+nsJs0zonBdymwM5WQ9daOhYpvDTN8en6S9d5Wl/NJENritbg3nS/TvfM1IfpvKXrJM1npeTrLJ33tJ5Ma9HWnknSOraUfK9Lxzb1+jghnq1jmYrS8Rvq43S8Uqhk6uO0Xk7XQJojUzhnugcPvTbV0v0i9Xbq4/Te9FuGjmO6ftMYU4+lWvru1gdoTHYfz+w7BAAAANA9mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LVJe9rIKFpTqlOq+zXXXFPVtm/fXtU2btxY1VIa86ZNm+IYU6r4tddeW9VSWu6qVauqWkp5TcnLKeU1pTuXkhOZ0/ekJOnDhw9XtZSEnp4mkNJuZ6J0XlJ6dUp1X7duXVVbvHhxVXvssceavuPWW2+NY0xJy9u2batq6QkRN9xwQ1VL6cfpaSPpvSlVv5RSXn755aqWEqevv/76qpbmjdTbKSl5Oifet6ZPD0lP3khp4SlNOz0VIT1hI82xQ0/ySP2Qfk96ikh6ik+ae1955ZWm8aT7SCl5nk2/O313miPS011SMvi453qqGfpt6X6Y5r/WFPbWJPw03ww9BSHNV+l+mnpkyZIlVS3dM9I9O127Q/Nf65OG0jouSb+v9UldQyn801U6pul8pt5MtfR56ZimXkhPcygln8/0/jQfpv5vfdJJ6/VdSu6ldCzSE//SHGvezYauz7RGTXNQmmtSv6ceSa9LfZi+t5Q8d7Y+ISc95Smd+9ZrYGguTuur1LOtT8hJx6zXeXf6rs4BAACAacHmBQAAANA1mxcAAABA12xeAAAAAF3rMrAzSSFAKTQkBbJt2bKlqt14441V7ZFHHqlqDz30UBzP448/XtXuuOOOqva9732vqt12221VbceOHVUtBRCmMLgUAFpKDnlLAXEpfC9Jx7s1uGXodVMtwCj9jqHfkEJ2Tp8+3fSZq1evbhrPzp07q1oKvhwK7Ew9sn///qqWAjZTOO7nPve5qpbC3K677rqqlsKHSsnXRgp8ag1JSv2eQpJ6DSqabCnYKQVApX5PQa+plqTAztSvpeRzla6DFKq8cuXKpvGk7z5w4EBVS8F4pbQHL6ZQsHFCuFKQ3XQ2yj0lBZSlY5iCiNN5TuFvaa4aGmO6P6c1Tbrnp9elUMU07tYAw1LyPSxdq629mMIXZ7qh+0zr+iPNxam3ktTryVAPt14D6bynMaYeTmGKrSGQpeQ+TMc2rRXSnJGkczDTQjyH+rg1DD0FWqZ7Yevntd5vS8kByGnuS69La97169dXtRQom8KKU3BpKbkX0/vT+jZ9Zmu/97AO9i8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrkxbYOUr4XQoxSa9duHBhVUuhfynIKtXS56WAt1JKefrpp6taCth89tlnq9qmTZuq2gsvvFDVUgDol770paqWAkCHxrhmzZqqlkJAU0hSCnhpDcqZzoYCl1JgWQrEWbBgQVVbunRpVTty5EhVS+ckhXOuWLEijvGpp56qailYMPViuta2bt1a1VJY0IYNG6paCjkqpZRXXnml6TNTGNPu3burWjoH6bfMtMDOUULiUuBZCuJMIaqpv1KIYAoBHBpjCudM83EKzUrBcXv37q1qe/bsqWoHDx6sakNBh6nHUlhYOj4pjK41bHKmBXYO9Ug6himArXXeTuuUNJe3BgmXUsq6deuqWgo3TiGzaU5MgYUpeDbVhoIb03XZeq22hkaOG2w4XefpFMaX5ovUm6mW1g/pvKdQwqGgwzSfpvV26vUkzaepdvjw4aqWwsdH+Z7UR+kcpLnFXDx8zabjlY51OoapF9N9PQW9p/n5xRdfjGNMoflp3GkuTvNuuv7S+jSt1VNvD333rl27qlqad9N13noN9MBfngAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQtUkL7BxFCiBKUlhJCpC86aabqloK3UnBlykEq5QcupkCjNauXVvVUnhKem8KwEsBNul1peRAlvQ9L730UlVbvHhxVTt58mTT56WAl1HCtno2SpBYayhRCiBK10AKB0xhcKmPh0J3UljrNddcU9U2btxY1VKIUBpjuk5T36RgzlJKOXDgQFW7/fbbq1o6D+n3pfOSgrR6DSq6WIb6OM2pKdA3zZVpbkrHP/XSqVOnqtpQ4F8KVk6hsCmwK82T27Ztq2rbt2+vaimocOiekerpmKewr3QsUmCnAOXh67Y1+C+tDVLfpGsgHf9RzklaL6T7Q/qNKfwtBRamay1dA0MhcSlcNwWfpntYOrYpyC4ds5k2H7dKYbJprXbVVVdVtdY5KQV2p0DkUkrZt29f03enkNiXX3656b033nhjVUvrhKGeSQGiaY5NxyL1ZppHWnt4aIzTYc089BvSNZ/WsmmOTf2e5r50TtI9884774xjXLVqVVVLD1ZI/f7kk09WtQ9+8INVLQXmtj5UYaie1inpGkrHIoWKp/m+B1Y6AAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1SxrYORTmksLzUtDTxMREVUtBMCl4Jb0uhQANhW3dfPPNVS0FxKRQoxTIloK6UojWwoULq1oKjSsl/8YTJ05UtRSg1xp2k85hCiCaiUFy6TikPp4zZ05VS0E+KYRr9erVVS31+5EjR+IY07m/4YYbqloKTkoBm2ncK1asaBrPc889F8eYjmM6ZiksNF0bAuJGk3o2zdFpLkjvTfNaqqUQwKFw4hQOmALA0jWUevHZZ5+talu3bq1qKeQt9eaQNJ5US98znYORW40SoJykPk6hsEuXLq1qKTw79WwKdEvz7pB0z07Bhul79u7d2/QdaX5P82QpOWw5rUvSZ6ZrMoVGpvMyyjGbSkYJcUxSv6c1QArdTmF8KeQ1hQju2LEjjueZZ56pam9729uqWrpWUujm29/+9qq2fPnyqpbuIUPrzhT6mEKaUxBkmt/TejmFJI47X0016ToupT3gNPXYrbfeWtXSHJnWnalHXnzxxTjGFFic5rT0W+67776qltan6fd9+ctfrmppvi+llJ/92Z+tamnuSPNuWs+kXmw9V5Pt0o8AAAAA4KeweQEAAAB0zeYFAAAA0DWbFwAAAEDXugzsTFLwWwqUSsFtKWAqSaFTKTytlFKWLFlS1Q4dOlTVFi9eXNVSIFIKH03hRSkwZteuXXGM6fikAK90bFMATmuo4XQOIBpFOjatYbQpoC8FlqUgnvR5qTdLyec09XYKOkqBP+nz0jW5efPmps8rJQdfpRChdB2kkNkUuDVuaNp0lq7n1McpwLA1kDId61GColLoXwple/XVV6tamhNTYGd6XRp36tchaZ5N0rFN13mqzbT5eJTf29rbSZqj9+zZU9XSvDTUx63rijSv7dy5s6qlUMQU5phqQ8chrStSz6fXLViwoOl16dqfSXP0KMc+9VJ6XQqiTeGaaZ5L82uaS0vJY7/zzjurWlrLpj5KvZmCDh955JGqdvXVV8cxpu9JAeTpb4fUwymEP52XHoIOJ9PQ9ZmOQ/pbKd330vrt0UcfrWrpXvjUU09Vtd///d+PY3z88cerWgqP/dKXvlTV0vWSrr8UuJ96LoXol1LK008/XdXS/Sbdl9K9IfV264MaJtvMupIAAACAKcfmBQAAANA1mxcAAABA12xeAAAAAF27pIGdQ1qDmVKQSPLGG29UtRQimAIRU2BMKTlQKn1Pev9rr73W9N7Dhw9XtfSb9+3bF8eYvjuFf6VwmTSeFDiTvqM18Gy6GCU0LAXdpL5LPZKOazp36b2pX0tpv9ZS4E8K9moNbUy9nWql5Gs1heWla6M16He6Br9dCOnYpJ5NoWWtc126LlKoWgrrGvrMI0eOVLXUiyn8LfV7a/hrCr0qJf+eofvLuVIfp+uihyCtS23oWk7HOvVxksJfU/B2Ch1Or1uxYkX8ntQ78+fPr2qpj1M4Ybpnb9y4sapdd911VS395lJKOXbsWFVL11q6X6X+TNfVTArnTMdk6DpOPZxCf9P9/ujRo1Uthftdc801Ve0d73hHVUth4aXkntu0aVNV++IXv1jVnnzyyaqW7isvvfRSVduyZUtVe//73x/HmMJCU3hiCtBN95o0xmQ6B9yP8jvSvSvNKy+//HJVS3NnOne/+Iu/WNXSPPX888/HMX7605+uamkuTn9T/eEf/mFV++M//uOqdtddd1W1P/qjP6pq9957bxxj6rt0LJI0l6R1dXrdKHPWxeJfXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA1y5pYOcowVop1CmFi6QgmBTSkgJ70ncMBR22BnGePn266XUpdOn48eNVLf3mFN41pDV0LoVtpaDD1lCumag1YCwFQKX3pt5Oxz8FCA2NJYWypRC71HcpYCm9N10Dqd+HwgtTEF1rOGe6ztMxm85BWq2GeiSd09YeSec59UM6J2leStdAKfkaSr2d7gVpjOlYTExMVLUU4DUUmJXCGNOcmu45qbfT9ZJq0zXosJTRgh1Tz6Z5pDWMNvVN6uM1a9ZUtZtvvjmO8c4776xqy5cvr2opLDmNMfVX6uO3vKX+71jpWiklB5CmY5Hm3nRsU29P555tMfT70zlOr124cGFVS0Ga99xzT1W7/fbbq1qau1LYZyl5jv7f//t/V7W/+Iu/aPqeefPmVbUUpLls2bKqlgIRSynlhRdeqGrpvpTW4Ol16RxYGw+v6dJxSHPV/fffX9XSNZB6+8/+7M+qWgp1fd/73hfHmK6N97znPVXtK1/5SlX78z//86r26KOPVrXrr7++qfaud70rjvETn/hEVUvXxnPPPVfV1q1bV9VSH6f5uQf+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANC1LmNEW582kp7akdJSUxJ9eoJBSrsd0vpUhTTGlOJ99OjRqtaa3j9Kou+sWbPOu5aOz0xLTx5X6s/US+l16SkE6dynpywMSZ+ZrpfUdyn1Of2WNJ407vR0iVJyknTqxdY+lgI+Wpr/OL2YpCcbpHOSUuuHnjaSErFTL6a+SfeCpUuXxu85V0r1X7lyZXxtejJJ+t2t8wHZ0LFK13jqxdQjqe/SuU/fcdVVV1W1m266KY4xPZkkfWbrE5zSdZGeVJLWJDt27IhjTO9P80Hq7XS8aZfOZ3p6TOrNdL9O5+3VV1+tat/61req2vPPPx/HmJ5Wktx2221VLT0dZOPGjVVt586dVS39vmeffTZ+9/e+972q1vokvnQOWueWmWZoXZXm0/S3UutTntKTZtJ1kZ7k8eSTT8YxpvvwRz/60aqW7vfXXnttVXvooYeqWlpntD6Fp5T8d2M65ukJaOkctD7NqIf1sqsLAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALrWZWBna6hhCohLAUQphCSF7qTakDSeFPjTGuKZwjnTd7SGcJaSf08Kp0uBiK1BhymUqIcwl6ku9XG6LlIt9eGQdA2lwM70ma3hdEkKxUv9VUops2fPrmopSKs1hFd/ZqOEQqbrPgVApbklnac0V7W+t5Tcd+NcQ+m7U3+m182bNy+OMUlhtqmWrr907Qr2HL6+U8+mvmkNim0Nnm29l5ZSyv79+6taCmV76aWXqloK0kzfnY5PGs+xY8fiGNOcmnq+9RrSs+3SuUvHL527VEvrzrReTv2fwjVLKeXuu++uamlNcfjw4aqW5r5HH320qqWQxeXLl1e1oRD+dB9J709rjzRGPTyadG9OPZbWeekaWLRoUVVLPXLNNddUtfT3WCk5eDb1cfotX/nKV6pamvu++MUvVrV3vvOdVW0osDOF2aa/OdN13ro27nW97F9eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXugzsTFIgTgpKSWE6KWQlhaeMEkySwtJaQzxbgzhTmNgo406BLOkzU601ULHXMJceXOhjk66BcUP7WgMMxwmiGwpZbHlvKe2hein0UaDsxdEa2Jlel7TOVaOEKqfznL4nhYKl706/ZSgQLkn3pnQPS/eH1uuUYa1hZOmctN7H0zlJ5/3AgQNxjIcOHapqx48fr2opxDNJ12Tr/DcUBJ56PtVGuVZp03rNpx5O5zOFqs6fP7+qpblvaCyph3ft2lXVjhw5UtVSv6awwVWrVlW1devWVbWhXk9jT/2a/nZIay5rimyU45J6LIVPpnN34sSJqrZ+/fqqtnTp0qqWzvFQ/dlnn61qt912W1VLQa8pXDPdB9LvS9dPKfl6SfebdE0nreu1HkydkQIAAAAzks0LAAAAoGs2LwAAAICu2bwAAAAAujalE5VaAwyTFGiUwmWGQolaA9TGCT9sDbwaCllJ35Nqgg4nz2SEeI77/tZgwtbQxvQd6TiM0set/alnL450XC/0eUpzeQpOLCXP5633hzTGccIGhwLAkjSecUN4GU86/q3Bfa3nLoUQDknBoCloMdVScFzrHD0URpuujVHWTuf7Osa7n7Wu806ePFnVRpnTUhBnGncKT0zhyWncqdfTtff666/HMab7RStrioujNRQ2BcCn96a1Qgo6Hprn0rx7/fXXN313CvxO10UKY07XxVC/pvl9aI10rtZ1ea/8ywsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6NqUDuxsDRe5lMFRrYF1KewuBWslQ8ehNRhP0OGldSmPdet3t4YxjnMNjdvH9Gec85R6KYVojfuZrSHPSWto4ygEGE6eCz1fXYyg6xRYmObj1nXFuNdQomenptb5sPX+X0ruw9aQxRQM2tqvKZxzaC5uvX64tFqDgNN5TqGZ6b0p9LKU9hDw1HfpAQyp3xcuXFjV0m8ZChBP18ZMWS/7lxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LUpHdjZaioEIk6W3sZDf1p7RC9xoUxWqPKFDhYUVMhfdaFDxIc+c5zvuZQB5lw649zXR7nXp75pDV5MIYnjjGcoVJSp60KvO0eZ54aCM1tel3q7dTyjhOPOFK5sAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOjajAjsnCwzOTwF4EISGAjjcQ0x1VlXc6FM1Yc3uAZq/uUFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LXLzp492/7iyy47UErZfvGGAyNZd/bs2aWjvkkf0xl9zFR3Xj1cij6mK+ZipgN9zHQw2McjbV4AAAAATDb/2wgAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTt8lFePHv27LMTExMXaSgwmj179hw8e/bs0lHfp4/piT5mqjt69Gg5derUZefzXn1ML863j/UwPbGmYDr4aX080ubFxMRE+fCHP3xhRgVj+shHPrL9fN6nj+mJPmaqe/jhh8/7vfqYXpxvH+themJNwXTw0/rY/zYCAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABdu/xSD6B3Z8+evWTvv+yyy8b67sn6TIDprnXuHPeeAQBcfL3dr/2N1sa/vAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArs3YwM7WkJah17W+/8c//nFVS4Es6fPS60YJc3nLW+q9qTSe9DpmrtSLrT2S+it93lvf+tbm8aTPTAQdTX+jnONx5vjWubd1Li+lvY+Z/iZrrkq92FobGqN5lsk0yhx7vq8b5buZGqbbwxb4/+evVgAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2rQL7BwnyKc1bHCU17Z+z+WX16fihz/8YVWbNWtWVXvjjTfiGNNrWwNEEyE0U9fQuWvtz/T+K6+8sqqlXjxz5kxVS7151VVXxTG+/vrrTWNMIaDjhH1xaY0SWNx6nn/0ox9VtTfffLPp81J/XnHFFU3fW0qez9N3J+beqWvcPh5Ha7+39mEpea2SAp1bQ57Nx31pPR+j9PC44fMtRlm/T0aYMxfHhQ5rHWX+aT33ae4bp29G6eOZMp/6lxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LUpHdjZGlbSGkqYQqtS4FUpOZDl9OnTVW327NlV7bXXXqtqExMTTZ+XwrLSbyklBx2m0LkUsphe1xpexORp7fcULFhK7uMUsJl6ZO7cuU3fc+zYsaqWrrX58+fHMaYeO3r0aHxty3hmSqDRVNJ6ToZCAFN4bJoX03zeGgibvjtdA2mOHvqedC9IY0xhtK2BiFxaowS1pflqqJ/Olfom9XHqwzTnD12TaYytYbatx8IcfeGNc0xH6eE0L6UeTnNaqiWtc3sKSR6qtwaVt8671sbjGyd0s7U2SvBs6304zX2t7x0lhLM1BDz19jgPb+iB1Q8AAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdG3KBHZe6CDOFHSSAlVSaGYpOYgzhV61hm0dP3686TsOHDhQ1dauXRs/c+fOnU2vPXXqVFUbCnhsMZVCX6aSFO6T+j314VDI1Lx585rev3///qqWwgpTfx0+fLiqpd5cvHhxHOOSJUuqWgrsTH28YMGCqtZ6HBlN63XfGh6VDM1Ls2bNqmqtYVhHjhypamk+ToFwKWh50aJFcYzpukr3ofS6dHxSSKm5d/KMEyaXzl0puY9be3sonPBcaZ5M65wU7Dn03SlsOd1bhn53CyGe7cbpzWSU4MoU3prOe2vIa9Iarp8CkUvJAeSt96D03a3htAwbJ3RzlJDLcw31cfrbrbW3W/s9SX+HDs3FqefT/J76fdxA00vNv7wAAAAAumbzAgAAAOiazQsAAACgazYvAAAAgK51Gdg5TiBLCjBJUoBJCkoZCitJgW4poGrv3r1V7frrr69qzzzzTFW7//77q9rWrVur2vr16+MY0/E5ceJEVWsNKr366qubvqPXgJdetfZ2Ok8pBCiFVB07dix+97Jly6raihUrqtr27durWgrdvOWWW6rahg0bqtpzzz3X9B2llHLNNddUtYULF1a1bdu2VbUUnJSCcBlNusbHue7TfJyC0dI1UEq+DlJYawpWSyHIKRA2XVepD4cClNP9Ic2zaY5OxyLVWgOiGU1rEHh63ShhfimcM4VhpnktBXamMLoU/pZCa4fuGel70vU7TmidcM52FzrUsHUeH5pr0jmeM2dOU621P9J1ltb+6RotpZSTJ09WtdYQ3PQ96b1DQZCM15/jBH6n9cNQH6e5OP0NlPo4rTFbg5fTNZBC70vJv2fPnj3xtedKc3bq917/nnN1AQAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXpky6V2twSwroaQ2TSsFtQ+FrKXBwzZo1Ve2VV16pailkZe7cuVUthWil8QwFHabxvPTSS1Xtuuuuq2opICYds9bgvl5DXyZb63FoDZRNYW6nTp2qaqkPSyll5cqVVS2Fbm7evLmqpWvg4MGDVW3Tpk1VLYWCpt4spZQbb7yxqi1durSqpcDOFMzVGgrGaFJvtwZIpn5vDa4sJQfPpjDNNM8eOnSoqm3ZsqWqpfDlFMKZAmZLyXP3xMRE03jSsRBqeHGk45qCzFrD/FJtaA5K10vq2VRrDQtN11q63585cyaOMa1L0ncvXry4qqWAujRvtIb3zTTjhBq2Bsym8zFKIGXq7dSvrSGeqYfTNZXmyLQ+KiVfuymQOV0rreGQwuxH0/oAhtbAztSfaX4dCgFP4ZwpiDPdw9N7U2BnqqU1a1ovl1LK7t27m8aYQpqneh/7lxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LVLGtg5FMDUGkqUAqVSuE8KEVy9enXT5w0FxC1YsKCqpaC166+/vqql8MS77rqrqn3jG9+oaj//8z9f1T796U/HMW7cuLGqpaCiY8eOVbV0vFMQZAqH6TXgZbKl49AaIpTCo1LoTgoBTL39/PPPxzGmYMJ77rmnqqX+fPLJJ6vad7/73ar29re/vardeeedTZ9XSinf//73mz4z9WIK8UrXuRDP8aW5NwVXpTkohQAePXq0qqXropQc4JoChlPwVfrMF198saq9+uqrVW3r1q1VLYXglpLDPVNYWOrjFBw3E+fUcbQer3TPbw34S3N0ui6GgmxTyGXq47T+SJ+Z3nv69OmqlsJoh+bEdA9rDdFrJZwzaw3nTP2a5pDU62lOStdOChsspf0+kN6fgj1TIGK6X6T1d7qeSsm/MV0DKTAyXXutYahD4ZDT1Sh/47WGHada+rzWsPCh16W5M92b0329NbQ2vS6tT1etWhXHmNYpGzZsqGqpt9N1mub21ocHTDb/8gIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOjaJX3ayJCU0pvSjltTUFOqakomXrNmTVVLafKl5CcyPPLII1XtN3/zN6van/3Zn1W1ZcuWVbWUTnvy5Mmqds0118Qxbt++vaotWrSoqu3Zs6fpdSmlPCXypsTaodTh6ZyY3/rUnJTEnZLs03lKqdtve9vbqtrQ00bSEz7S99x7771V7ctf/nJV+8EPflDVUh+mROR0/ZVSyubNm6taShFP136aS1qfCJD6eCZqnY9TLc1h6bimJx6l1O39+/fHMS5cuLCq3XbbbVUtPYEp1davX1/VXnjhhaq2b9++pteVklPJ01NSUgL5nDlzqlpr6nprbboYuqe09mySnt6QnmSUaqnfh7433XfT9ZfuGamWnoKQnvKQUvRHeVJD6zogrdlanwowk4z7lIZ0j0vrt9TX6Xy0rluGXpt6IdVSH6V7SFq/p+OwfPnyOMbWJ16lOTtdo+k+4Gkjw9KxSXNVmi/SuiDNp6kP0711lPknPWkm9V16qln6Lem98+fPr2rpqYCl5P5Or02/Mc0HSa9rBatzAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOhal0lJraFEKXgqBbpde+21Ve3xxx+var/4i79Y1Z577rk4xhSqkgKuUvDiXXfdVdVSqOH9999f1VIYXPp9peTfmMZ46tSpqpaCk1JoXArZ6TXgZbKlUKIUFJUCoFatWlXVUhhmCuJ897vfXdVSwGwppTz22GNV7bvf/W5Ve+ihh6rae9/73qq2bdu2qvatb32r6fOG+vjrX/96VUuhREuWLKlqqRdbw6LGCfibTlqPV5oz0hydwjVTeFSa69I8WUruuxSils5fCtdKvZjmznS/GRpjCvtKUkhcmntTcFkK6jMf/0Q69ylAL4WbpWsg3TcPHz5c1dLaJdVKyfeCdE5bx53uNyn0O4UnDgUor127tqql6zfVjh8/XtVSb6ff0hrKN52lPkzzQOrNFCab3tt67FOQZim5v1IPT0xMVLV0X2kNw0zz5tGjR+MYU0B0en/6jenaTeMR+D18fbaGc6Y+Tj3b+h1pjZLmyFLyOU3nPr0/vTetFYauoXM9/fTTsf6+972vqn384x+var/2a79W1R599NGqlu4/rffDye53VxcAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdO2SBnYOhbmkMKoUNrR06dKqtnXr1qp2xRVXVLUUFnTw4MGqdscdd8QxvvTSS1UtBRg+88wzVS0Fg37+85+varfddltVe/nll6vaUODM7Nmzq1oKFEtBKykoJ4XvpVCcmWYoqCbVUx+nMKsbbrihqqV+T4Gdr776alUbCuy8/fbbq1oKqU2fee+991a1FK6ZwhSvueaaqjYUXpTqBw4cqGrpeKcwuNYQT34iHa/Us0k6rimwM31HCq3dvHlz/J40r+3cubOqHTlypKotX768qqXw11RL96o0llJK2b17d9Nnpn6/6qqrqlprsHW6P0znoMOhUN0UPJbWBmkeSe9NxzAFdKfa0D07zfEpADHdd1NA5p49e6rajh07mj5v3bp1cYxp7bRr166qlgJ3029pPS8zKbBz6He1hgimnkshlaln0pyW5p/03lLyvTkF3Kd5LoUapnkzhd6n6/bTn/50HGNay6a1flr3pOsn/b7Wfp0uIeDpt40S2JmCOFMfp2DP9HmpH1LPDq1lli1bVtX27t1b1VLfpLnvxhtvrGppbZzmvhSSXEop3/ve96razTffXNXSNZTWxml+SfNBD/zLCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2pQJ7EyhNin8afXq1VUthWved999Ve2xxx6rah/60IfiGD/5yU9WtY0bN1a1FGSVAqo2bdpU1Y4fP17VUnBLCqYrJQd2Hjp0qKqlkBYBhuNLwTspXCuF6bztbW+rail089vf/nZV+8Y3vlHVHnrooTjG973vfVXtv/7X/1rVUohnem8K0krjSdfkkKuvvrqqpfCxNB+kYK40lwyFrk5X44aEpZCrFIbVGhC8cuXKqpbm0y1btsTxpHkthXOmwK3UI0maT9N7U8hYKTkEOR2z1tCsmdazSerjod5uDSJMtXFCVNO8NHR/PXr0aNP7Uy1dkykQLt1vFi9eXNVSeGgpOeA2BVGne10a43QOMbzQWkN603FOPZPmqrRuSa9LgX9D353mvhS8mMIwU+hsCgtPIbhp3VJKDk+87rrrqtr3v//9qpaC/dM1kcaTatO510cJ7Ez90NrH6V6YXpd6OwWFDr2/NfAzBWmm9cwTTzxR1VKY/VCPfOpTn6pqf+fv/J2q9u/+3b+rar/xG79R1dIDIRYsWFDV0vEeOtcXq7+tfgAAAICu2bwAAAAAumbzAgAAAOiazQsAAACga5c0sHMoyCOF2qTQkO3bt1e1t7/97VXtc5/7XFVLATsLFy6saikMqZQcnpjC6R544IGqlkK5brjhhqr24osvVrUUHDYU/pVCcdIxT0ErKVQ0hbSkELSZZiio5sorr6xqKfQv9fG+ffuq2u23317Vrr/++qr2gx/8oKql4LZSSrn77rur2vPPP1/VUmhWqqXgxSVLllS1dK0MSX2Xgpda35tq0zk0q9XQMWgNZ0oBmSmwOL1u3bp1VW39+vVVLc2TpeT+TmM8cOBAVUu9lObodHxSmGyad4e+p3U+Tp+Z5v303qH5aaZJxzrN0ek8pfXH/Pnzq1oKMWw976XktU8KJ05zbwqTS0G2KWBulPkv9WJaJ6V5Ix1va4h2rdd3OkcpNDO9Lp23NGenua+UHCqfAj+ffPLJqpZ+S7rOUhBn+n0piLaUPPYU5pyux9Y1uHl3+Bik45XmkBTimR5kkHokzZHpb7wUwFpKHntap3z605+uaumBEB//+MerWlq/v/LKK1VtqI83bNhQ1dKaKz0QIh3b9PdJr+tl//ICAAAA6JrNCwAAAKBrNi8AAACArtm8AAAAALo2aYGdKfwkBYGUkgOlUhBWen8K7bnxxhurWgp4e8973lPVdu/eHcf44IMPVrWXX365qqWAlxSUkkK90m9OQYdD4YUpAKc1PGzWrFlVrTVsK31eDwEvF8tQYGrqz4mJiaq2ZcuWqpYCqW655Zaqlvrws5/9bFV7+umn4xh/6Zd+qaql0NsUHpuujdQP6TenQMSTJ0/GMbYGJbb2bAqjnWk9mwz93nS80nFN81oKzUoBtSmQKvXNxo0b4xiT1A8p7Cv97jTPput83rx5VS0dm1JyqFiaj1OIXjq2KUxuKCx0uho3oDTN0VdddVVVSyF9KcRz6dKlVS31zdDaJ11rKUgw9U1rLY0x9exQkF0KXzxx4kRVS+uXdGxbw5cFILaH57Xeu9J9NPVgCn5NofellHLddddVtRdeeKGqPfvss1Xtt37rt6ramTNnqtpf/MVfVLW01v7Zn/3ZOMa0nvna175W1ZYtW1bV0vWc/mZpDQufzsZdQ6Vjnfoz3QvT/T8ZOidpXkrzVwoBT8Hif/RHf1TVfvu3f7uq/Z//83+q2v333x/HuGbNmqr2la98paq9//3vr2qPP/54VUvXburt1jX0xTSzriQAAABgyrF5AQAAAHTN5gUAAADQNZsXAAAAQNcmLbBzFCn0LwVxrl27tqrt3Lmzqt1zzz1V7fnnn69q1157bVUbCmNMQUdpPClIJgVmpQDD1lC8UaTPTCE0s2fPrmopAKc1QGo6GwoSS+c+HdcUfJUCZVPQYQrxTAGgKfStlFL27dvXNJ7UnymkLZ371sDHdI2Xkvsz9WIKiEuv6yFsaCpJ13hrYGoK99uxY0dVW7lyZVVLYZgpxLOU3LPp+jt9+nRVS8HGadzpvrRkyZKmzysljz31dnp/mmNaX8dPpHt5CjhtDdhMIZ5pDZBC/4bu42kOfPXVV6ta6uMUtta6JknhnOk+UkqeP1MtBdSm453m3nGDWKe6oftR6sN0L03zc5pP03lr7f90vy2lPdTw2LFjVS2F4O7fv7+qpfX7ihUrqtqmTZviGB977LGqlv52SMGL6RptXb9bZ/xEupe29naad9P6NgXPp5DY973vfXGMaQ2eejbNsf/23/7bqvbud7+7qn30ox+taqmPN2/eHMeY1hTp2j9y5EhVS3+LJL3+jedfXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA1yYtsLM1lKmUHPiTAtRSsEkKVEnWrVtX1VIA4caNG+P7T548WdVSeFsadzoWZ86caaqlwKuh45jCbpIU2pRCX9LnCT8clkLZ0nFNYYWpj1Noz1133VXVbrrppqqWAqVKyeGJCxcurGopnCt9ZurZFCyYemkoQCi9tjVALIVIprComdazowTipeOV+jiFR6UeSXPinj17qlq6flLY4NAYUy+meTu9N82zKYCwNfCulPb5M/3G1mDJmR50WMrw703HMPVImltef/31qnbFFVdUtdWrV1e1NK8dP348jvH73/9+VUtzdLo2Urjg+vXrq1oK+0zBzSnAsJTcx6tWrapqKVgv9XaqzbSebZV6M/VhCr5M97g0P6fPS+c33VtLKeW5556raosXL65qab2c3puuvQ0bNlS1dP/funVrHGM6FilIv3U9k84Lw+uqdM9N/dQaKpn6K833qUeG/k5Kc1Dr3PeVr3ylqv3e7/1eVfvd3/3dqvYf/+N/rGop2LOUfB2kYN4UaJruVWl9lOaDHrjiAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArk3a00ZGkRJqU+JpSs1evnx5VTty5EhVu+aaa6raqVOnqtqyZcviGFNCdnp/GmOqpZTXVBtK209Sem86jinxPj3xJb03pSzPtCc3DP3e9DSAlJydntyQnqRz6NChqpae0pDShof65vDhw1UtpWmncafPTL3dmtqckqBLyccx9Wz6zNSznjaSDSX8p+OfjmF62kg6/qmWnr6Q0sJTfw29P722NeU89VJK8E9PVEjXTyn5+Ka+a32ySOt3zDSjPG0kzWvpdWmuS+cuPalp0aJFVW3o6QStTzpJ/ZDu2Smtv/UpPulJC0Nj5MIauh+1ro3TXJzumWneTE9uuPPOO6vad7/73TjG9HSc3/iN36hq6alTjzzySFW79tprq9rP/uzPVrVXX321qj3xxBNxjOnvhDRvp+OT+t9T9/LvHWWeS/fSNBeneS79PffKK69UtQ984ANVLfVcKaX83M/9XFX7wQ9+UNXSU5nuvffeqvanf/qnVe3BBx+sal/60peqWromS8l/E7T+ndZ6T+uVuxAAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdO2SBnaOEnSYQlpS4EgKqEpBPCmMKoW0HTx4MI4xBb+dOHGiqqVwrBRUlIKB0uvS5w0dx3TMkvRbUk04ZzZ0DNLxSucvvS6FA6aePXDgQFVLwUdDUs+m70nBSel16fe1Bnamnht6fzpmenY8Q0GHrUGTKXi2NTA1zdFHjx6taqlfh+rpM9OcmHqxNRA2HZt0DZSS71fpuhK6eXGkdUU6V6lvWkOD07lrnU9LyaHFKbw5BbilMab1S7qu0nvnz58fx5iu8zQf6PcLLx3n1IdJ6q0lS5ZUtRRmmebxoWDitAZPa5IUcJ/Wwen3pXG/+OKLTd9RSikrV66saingOYXlpnNgTTGacXo23YfT8U99mM5x6rlS2ufTtKZYunRpVXv88cer2q//+q9XtU996lNV7T3veU8c49atW6ta+t3peKe5uPW89MC/vAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArk2ddI6gNRAxhQ0dOXKkqrUGvJSSQ+dSAEoKrUohQK1hQa3BYaW0hxWmmqDD8aXjlcLJUo+k/kpBRSmQaigMLknjSb2YXpe+pzWQrTVcc0hrH+vZ8bUG6qVjncKs0nluDTpMc2IpOTyuNWi0Vfq8NB+PG0CoZy+Occ5fOifpvSlkO83RQ308MTFR1dI11LpW2b59e9N3p/l44cKFcYytoW6t1yTtWtdqqTfTOnjNmjVVLfXC7t27q9qqVauax7ht27aqlvrw2muvrWpp3bNr166q1hrGXEq+t6Rjlo6F+bndKGH26VinoNfUN+nzbrnllqq2c+fOqvZLv/RLcYwpDPOuu+6qainwM/XSrbfeWtX27t1b1TZs2FDV0n2llByePM56bSrxLy8AAACArtm8AAAAALpm8wIAAADoms0LAAAAoGtdBnaOEySSwg9bg7pag2BKaQ/wSgGGKcgq1VrDD4eO1zhhQ1M9zKVX6bim89wazJXeOxQGd6GNE742Sjgnl9Y45znNia3XwCjhxCmsbZwA0dawwdY5f+i1XFrjhJul83ny5Mmm1w3dX+fNm1fVUmhdkgI7UzBhkq6BWbNmNb13iH6fHK1B1WnuTIGWKRwwrauXLFkSx5Nee+DAgaqW+iuFgKbPO3ToUFUbJbwwfWZinXJxpP5Mf68k6R7eqjVsuJQ8n6Z+aP27MY07PThi/vz5VW0osDN9Zpp3p2MfT79fBAAAAEwrNi8AAACArtm8AAAAALpm8wIAAADoWpeBneNIAT2tYZitIT6jSOEpaYyttWQo/Evo5tR1oUMSR/k8fcP/yzj9OU4QcQqYK6U9iCu9bpwA0VHm7XGOGZdW63lOPZJqQ+F0rcFq6btbe7Y14HFoLPq4f63nOPVM6s3UC0OBrKk/Wj9znGDBUdYtowTfMznS8U/nKd3DW+fdiYmJqnb06NE4npUrV1a1FMicQpZbr7/WkNmhdU8yHcM5k5nxKwEAAIApy+YFAAAA0DWbFwAAAEDXbF4AAAAAXZsRgZ2t4TxDAUQX2oUOvBI0xP+LHuFia53XWufoFDw11McXOoBtnABlgYZT2zjnOfVcCiscpY/H+e5WenZ6ae2FtOZtDT8eCrgfJ3Awheu3hskKJZ9+Ws9Ta0BmMhRwmebt1J/pda1/S7YG4erXmn95AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABdm3aBna0EVAFcXJMVTnyhA63cH/irWvth3D6crNBwGNfFCMi80EG0zAzj9MhQYGeai1uDYscZj35v419eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF277OzZs+0vvuyyA6WU7RdvODCSdWfPnl066pv0MZ3Rx0x159XDpehjumIuZjrQx0wHg3080uYFAAAAwGTzv40AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXLh/lxbNnzz47MTFxkYYCo9mzZ8/Bs2fPLh31ffqYnuhjprqjR4+WU6dOXXY+79XH9OJ8+1gP0xNrCqaDn9bHI21eTExMlA9/+MMXZlQwpo985CPbz+d9+pie6GOmuocffvi836uP6cX59rEepifWFEwHP62P/W8jAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF27/FIPYDo5e/Zs0+suu+yyC/od43weXEitvdh6rQBwfi70WgMulMnoL2tjmJ78ywsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrnjbyV4ySfjzOUz9+9KMfNb33LW9p21v68Y9/HOut45HIPHOlc596O/VY6zXw1re+taql3h66/qTe83+NO1eN09ut4xkao3mW83Gh57/Wnh3q1zQeczT/V2svXOjXJUNraHMx/9dQf12qHvFEyTb+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdG3GBnaOGzqVQt5agzivuuqqpveeOnWqql1+eX3KUq2U8ULnWsNCmdrSeU4Bm2+++WZVO3PmTFMtufLKK6vaUB8zM40bhpn6OEm9/cYbb1S1NEcnQ9+b6oK4Zqahe3NaV7TWWl1xxRVNtVEI7ORCaO3r1G9pHh9aU6R1zyj3G/p3Meak1r4ZRxp369qjlJnzt9vM+JUAAADAlGXzAgAAAOiazQsAAACgazYvAAAAgK5Nu4S81pCW1sCfoaCUFIqSQq9ee+21qnb06NGqNjExUdXmzJlT1U6cOFHVTp48GcfYGszVGmwn0GhqSKFXqbdLyf2dAmUXLFhQ1VIvHTlypKodOHCgqqUw2qHQuFmzZjW9Vn9OL2mOHjqfqR9S36Racvr06aqW5t70uqFrLd0zxgnXEpI4dQ0FE/7whz+saikEOb0u1VKPXH311VUtze9D10pr2Ln+nN6G5uLWUMPWdUrrvNna/6N8dwoWt6a4tC70vDJ0D0711A+tf1Ol/kzr7/S6tCYfev/rr7/eNMapHuw5tUcPAAAATHs2LwAAAICu2bwAAAAAumbzAgAAAOjalA7sbA2JGiXAsFUK3UxWrFjRNJ5XX3216XWLFi2qakMBQiks9PLL61OeArxSQEwKoRFeNHlaAylbA1hLKeXYsWNVbf/+/VUt9fvatWur2rp166pa6tlt27Y1fUcppbzxxhtVbfbs2VVNz05drQHKowSwtYZ4zp8/v2WIsT8PHz5c1VKI55DUn63HIhGSeHFM1pyR+jgFuKV7e5rLU3hbmjtT8NuSJUviGFt7tvV+JexzcowSgHyudM6H1hlpjTkUxn2u1Net94H0unnz5sXvSWNM83v6zHEC7hnNOA9gSFJIZeqFUvJaIc2drf2e+iatFY4fP17VUuj90Hha5/dUm0rrZf/yAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6NmUCO1tDnVprKYgnhacMhfMsXbq0qqWglWeffbbpvTfffHNVSyEtW7dujeNJUoBhCpdJIWFJCrBpDeViNK19nAKI0nmamJiI37Nw4cKqlsJjX3zxxar2wgsvVLVrr722qqUQzxQGNxRKmIK0Us+m45OOxVQKJZrqWgP6WoMKT506Fb8nhboeOnSoqp08ebKqrVq1qqqlkNnWYM8UOldK+zybgrTS70uvE3Q4vta5IM29qZY+L71u6LVpXkxBnOncp35P65wUMDcUspjqrXNvWpO00tvtxjlW6f7YGn5cSj7HKRT+yiuvrGpz586tammeS329a9euqjZ0naWw8XRdtF7P6Rq1phjNOMG9rWvj1NtDfZx6MQXApjV06tnUX+l1aT0y5MSJE1UtXQep38cJT+6ht/3LCwAAAKBrNi8AAACArtm8AAAAALpm8wIAAADo2pQJ7ExSkEgKQEnBb0kKFTpy5Eh87Z49e6paCiZ88MEHq9qWLVuq2qOPPlrV1qxZU9VSIOKOHTviGFNgXQpJSmFDKdgz1VoDjRhNOoapt1NwWwo1XLx4cfye9evXV7Ubbrihqm3atKmqfeMb36hq3/rWt6rac889V9VWr15d1dL1V0q+ftOxSGFMenbytIb3tgYdpnOcaqWUcvjw4aqWwqxeeeWVqrZs2bKqlkKzUuht6q8hae5NQXip31tDp1tDuPiJccI5W4MN03kfChJM5yqFxM2ZM6eqpV5Mvy/1V2sYdyk5kDbdh1LAbescrWfbjXOsUh+m85H6IwUallLK7Nmzq1rq13RdpLDP1t5MAfdDAc9pbZzuISlcP40nfU+vQYc9GCeIs/W4pt5O/ZX6tZR8v09zcfrMBQsWNNW+/e1vV7Vjx45Vtb1798Yx3nLLLVUtBYOnOTuFgKff3Bo0Ptn8ywsAAACgazYvAAAAgK7ZvAAAAAC6ZvMCAAAA6FqXgZ0pkCWFhqTwttaAlxRgkj5vxYoVcYwp0O3FF1+saikg7v77769qKXjlmWeeqWpbt26takOhcSlI5syZM1UtHYv03lRrDQkTVDSsNWwohcElKYzq1Vdfja/dvn17Vbvvvvuq2j333FPVbr755qr2+OOPV7Wvf/3rVe2ll16qaikIq5Qc9jUUsnSudMxSaJyeHU3r8Uq1NI+k8LYUjjUU6pqkeS0FLafA4zSXp9DbRYsWNdVKycGgCxcurGqtoY8peLHXcK2ppPW6bw02HGX+Suc+rV9SQGAKyEzXS+s6J31eKTk8Lt1Hjh8/XtXS8WmdyxkvnLN1fk49OEpgZ+qb1qDDtD5NtRSkuWHDhqo2FNiZfk9aq6drJYWNWyuMr/Vvt6R1DZ3uo0PrzjR3pp5fvnx5Vdu9e3dV279/f1VLa4pU+8EPfhDHmNbRaT2THhyR/pZMa4p0bNMaerL5lxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LUuAzuT1jCX119/vaqlELOJiYmqdvr06ar2/PPPx/Gk96dQlBQ29PTTT1e1FASzadOmqpbCYTZv3hzHmMJX0jF78803q9obb7xR1VJ4UXpvD2EuvRonlCgFC6VwwBRm9fLLL8fPfOGFF6ra97///ap2xx13VLWf+7mfq2opjHbBggVV7YknnqhqKTCrlFKOHTtW1VLfjRNqmM6BEK5hFzpIK4X2peC3tWvXxu9J9RSQmfo9XRsplDCFcKUxpjDnUvK9KR2L9JmtxzG9bpyQP34iHevWUOXU22n9UEoO90zzWro/p/tDmuvSnLh+/fqqNhRWnubzFIyYAjvTvJ3GaO6dHKmH0/qtNUS4lBzEmea0dA2k9fKBAweaamkdPDQXp4D8ffv2VbUUspiun1RLxywd7+ls6N7Tug4e597V2sepX0vJgZ2tf3OmtUcKrf3Yxz5W1a6//vqqNnS/ePvb317VUmBnWtMn6Xo5efJkVethvTyzriQAAABgyrF5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABdu6RPG7kYSbQpTfa1116raocOHapq6ckN73jHO+IYd+3aVdU++9nPVrXbbrutqv36r/96VUtJx1u2bKlqKa14KBU8SU9uSFICeEoKT3pIou1VOg7puKYE4/Q0nHSsU3J8StcupZTbb7+9qn31q1+tat/85jer2osvvljV7r777qqWEozXrVtX1VLSeCk58bv1CTkpBTy99/LLp8yDl7qVjmvrnJGS61PCdnraUimlbNy4sardeOONVe2GG26oak899VRTbdu2bVUt3UfS3FlKTjVPT5dofQLAOE988QSSYenYtN4PUy193tATuVI/pCc1pO9J94c0r6Ung6Tfl54qUkruz3Qd7Nmzp6ql6zx93kzvz1F+/zjzQKv03qHPS+MZurefK/VcmjdT/6d1/te+9rX4PenJD+lpPWntkp4edPDgwaqWrqmZ9rSRUbTOu0ma58Z9Gld6f+s9/Dvf+U5VS+vy9Pdl+hv2j//4j+MY03jSkyvvueeeqvaNb3yjqh09erRpPD38PedKAgAAALpm8wIAAADoms0LAAAAoGs2LwAAAICuTZmUuhTc8qMf/aiqpaDDFLCTwuBeffXVqrZ9+/Y4nhSAksJXXnjhhar25S9/uaql4MR3vvOdTeNJ4aGl5N+djlkKPxIsdHGkoJsUYpYcPny4qu3cubOpdtddd8XPvP/++6vagw8+WNUef/zxqvb1r3+9qqUQz927d1e11JspfKiUHIiUgjhbw5haA84Ez44mzdEpqO348eNVLQUJp2DBoeOfQg03bNhQ1dasWVPVVq5c2fR56TrdunVrVUtzbCn5d6eArHRtXH311U3fM06/z0StIXHpWKdaem8K5xya61LYWmtwXOqRdG8/cOBAVWsNzB1lPCkUMYW/JSl8uTW8j9zXqRfSfJrurel8DIUxt67LU8hrWruknnn729/eVEtB46XkMNnnnnuuqqUevvPOO6tamrNbQ0r5iXHuU2luaJ0vhl6XroPUs2l9mgLpk4997GNV7e/+3b9b1X7pl34pvn/ZsmVV7TOf+UxVS+uZFI67cOHCqpbWKK1hqBeTv1ABAACArtm8AAAAALpm8wIAAADoms0LAAAAoGtdBna2BrekIJ8UvrJ///6qlsJFbrzxxqbvKKWUp59+uqq98sorVS0FrSxfvryqpeC3FKyVAlWGtIaRpTCm9LuFeI4vnZMU6LZo0aKqlgLUUsDV888/X9WeeeaZOJ7vf//7Ve2v//W/XtV+8Rd/saql0NpvfOMbVS2FeKaAxqHgpBQGl45Z6tn0OqGbo2k9Xml+SP3+2muvVbXUDylAeSic+MiRI1UtBaulIK2NGzdWtZMnTzbV0u9LAVellHL55fXtNoXbpaC31oAs4ZyjaQ02TPfIFOiWQllTv6cw2lJyP6R5benSpVUtBXam96b+2rt3b1WbNWtWHGPqxbRWSfN5Wr+kz0vnQBht+zFoDTBsDf1Nc01r+Gopee5Ln5kCEXfs2FHV0vWYfsutt94ax3PLLbdUtYMHD1a1bdu2VbV0D2r9ffxE63Wberb1vWl+TsGx6dyVkuegVEtrj7QO/vmf//mq9sEPfrCqbdmypar9yZ/8SRzjv/gX/6Kqvetd76pqKZT8u9/9blVLc3EKc+6ht/01CgAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABd6zKws9Xp06ebXrd+/fqqlkLVHnvssaq2evXq+Jm/8iu/UtVSiFAK9kzjueOOO6paCpxJYUFDxyEFPKZQo/T+FHSYgm1ag+RmotYgrRQEmKxZs6aqpbDBm266qaql3i6llC9+8YtV7bnnnqtqKbDzgQceqGr33ntvVUshbS+88EJVS6FxpeReTH2cgoVSrTXEUx8PS9d9a2hZmidTUNu+ffuqWgpFLiWHe6Z+SiGzq1atqmrz58+vaun6S0Gjadyl5F5MIYutwaetwWX6eFhrYGcKuTxx4kRVS4Fw6TuG5rrDhw9XtbQOaO2H1McpDDr1XPrNpeSebw0xTLW5c+fG76FNaw+nPkrrkdTDqRfSPbiU3B8ptDb15pIlS6paulZSQOxXvvKVqpZ+Syml3HzzzVUtrV1aAwzT96T3jhJyOtO0hnOmPk79nqRzN3QfTffx9D1pfZvWFCkg83/8j/9R1f7Nv/k3VS3dF0op5amnnmqq/cIv/EJV27BhQ1VLPZt6u4cQT//yAgAAAOiazQsAAACgazYvAAAAgK7ZvAAAAAC6NmUCO1OQSAo7S2FBL730UlVLgSoplHAoIO4Tn/hEVXv3u99d1X7jN36jqqWAzIMHD1a1efPmVbXly5dXtaHAmRS00hoslMJzUthQei8/kQJs0vFKAYY7duyoailA6JZbbqlqd999d1W777774hifeeaZqvboo4821Y4cOVLVbr311qqWwn1WrlxZ1VLPlZJD3lIfp/5M3y1kdnzpGF511VVVLYWyLViwoKrNmjWr6Xu3bt0a65s3b65qqUfS3JvC21KIYPp9S5curWqpX0vJx2zOnDlVLd3XktaAM4a1XvcpJO7UqVNVLc2JKaxwaK5LwZfp/Wk8KYgz/b60hkhrjaEgzRSOm+5XKYg6hZy2Bv2SpWs+hWmm0M00R6ZQwnRvTeuWUvK5S6GbaYypr1OIZwq437ZtW1X77Gc/G8f4pS99qaqlIO/Zs2dXtRSEn/7uaA3a1evDUi+mvknHNfVnem86x6XkOTH9nZbm8i1btlS19Ldgmu8/+tGPVrXt27fHMf6Tf/JPYv1c+/fvr2rp/rVs2bKqltY9Pawz/OUJAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2bMoGdKWglBbKkMJ3FixdXtRTwlmoPPfRQHM/P/MzPVLUU7vnVr361qr3zne+sarfddltVSyFAKRBsKOwuBdGkMLgUOJNqgg5Hk45NCoVKAYYpECcFUr344otVLYVwfuADH4hjTCG1DzzwQFX73ve+V9VScFsKIEqhjen3DQUnpeCrFCCWjncKg0vngNGk+SEd/xRImfp97dq1VW3NmjVVbcWKFXE86dpIfZP6M82JKYgz3YPSe4dCjFMvtgaVpt+SagxrvVel+aE1rDqdk3QfT8GVpeRgtdZQxRSCnHo2hRinfl+9enUcY+rZtC5JvyWdg/Rb0jnoISSuR2kuTsc09VEKg01BfunYp88rJfdHOp+7d++uaml+PnToUFW79tprq1oKJU+hsaXkvxNS6OzRo0erWgowbA1nt14elnos9XH6uy/VWoNs0zkuJQfcpnOfgo3TeD7+8Y9XtT179lS13//9369qf/zHfxzH+P/9f/9fVUuBzJs2bapqhw8frmrp+KQ+7uFBDZd+BAAAAAA/hc0LAAAAoGs2LwAAAICu2bwAAAAAutZlYGcKtUkhUymQZe/evVUthYvcfffdTZ/35JNPxjGmcM5f+ZVfqWop9CqFJB04cKCqzZs3r6qlALzjx4/HMaaQpBQal8LIUlBOOi+ttZkoBWklKfTv+uuvr2qpl1J/PvHEE1UthXiWUsr73ve+qpbCPVMYVgrNSoFbKRApBdsNBWmm/kzS9atnx9capJWC3lJ426JFi6pa6u3169dXtdRzpeT5OPVia/DlUIjXudJxSKFepeRj0Tr3ts7HQg1Hk9YGaa2RwoTT/TkFBKZwzrQGKKWU06dPV7WDBw9Wte3bt1e1FJqZQhXTuFOo+TXXXBPHuGTJkqqWrt9x5l59PJ609kjzXJqzU8Bsa9hnKXmNunDhwqqWei595g9+8IOq9oUvfKGqpbVtCiAspZSbb765qqV1WPrudI22BogzLF3zqY9TGGbq49aeTee9lBzYmdYZ6XvSvT79zfnJT36yqv3hH/5hVbvpppviGH/7t3+7qn3lK1+pai+//HJVS9dkuoZ65V9eAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXpkw6RwreSQF/KeQtBV599atfrWopoCqFF5aSw1yeeuqpqpaCZO64446qlgJ/UvhXCqsZCoYcJ8AwBZkxvhSalYLWkhRWeOutt1a1559/vqqlEJ9SSnnkkUeq2u7du6vagw8+WNU2btxY1RYsWFDV0m9O18+QdJ2nnhfydnG0Bmmlc5pqqR+StWvXVrUNGzbE16YQwdTH+/btq2opUDGFcKVaksK6ShkO8jyX3p486d6X7sUXujbUC+meP3/+/KqWeiz1586dO+P3nCuFeKbvHfruNEen4MbWEGv9fuG1Bi+nOTuFVKb3lpLn07QGX7duXVVLc37q61WrVlW1FK75/e9/P45x6dKlVS0FiKbXta5HGN84PZv6Jr0uPSyhlPw354oVK6pauoekNXha51933XVV7f3vf39V+8xnPhPH+Kd/+qdV7a677qpq6bekY5H6OP0t2EMYrb9QAQAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArl3Sp42MkliaErvTkzyOHj1a1RYtWlTV3vve91a1rVu3VrVPfvKTcTz33ntvVXvnO99Z1VJa7o4dO6rawoULq1o6PilBNx2HUvKTSYYSos9XD6mzvUrHJiVVp/P38ssvV7X9+/dXtZtvvrmq3X333VUtPeGmlFKefvrppu9O6cmvvfZaVUt9nHouPXFiqDdbn5ojof7iaL3GU6L18ePHq9qhQ4eqWnoKyN69e6taSqMvJT8tIT35Jo0x1VJvpydBpHTuoT5Oqd3p/amWxqjfL440R6eng7Q+oSPVJiYm4nenvkvfk56CkNYGqWdTun56Ms9LL70Ux5iuq3QP8wSG8zc056ZrPs0rl19eL+3TGjq9rrU29FSldP0cO3asqm3fvr2qpaeSpLVCeqpgWuenvwdKyU9+aF0vp99nHTy+1MetT7pI10XrE+1mz54d62nu3LNnT1W7/fbbq9o999xT1dIc+cILL1S1NO+mvy1LyU/2SWupdP9qfRpUr73tX14AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNcuaWDnuObOnVvVrr766qqWAqpSqMn1119f1W699db43en93/72t6vapk2bqtqSJUuqWgo0SgFCKaAl1UrJAV6tgZ29hrRMdSnsKQWypdelAMMU/vriiy9Wtdtuuy2OJ/XnqlWrqloKCz19+nRVS8GCSQpTSv1eSu5ZYYWXVurPK6+8sqqlc5rmuhSslnou9XsppaxYsaKqpWDB1EupZ1NIXOrZ1kC3UnJoViv9PnlaA4JTYGEKf2t9XSk5sDMFqy1btqyqtd7b07op1YaCwNPxaZ33WwP4yNKxSsc0hXOmnkthsqmP0ncMBXamfk1r3lRLa4pXXnmlqj355JNVLa1b0vqmlDwXt4aIT6VQw1619nEKik3nLvViWnuk2tA8l9YU11xzTVVLfwumtcvq1aur2gMPPFDVdu3aVdVSYH4pec2VvifdV1JvT6U+9i8vAAAAgK7ZvAAAAAC6ZvMCAAAA6JrNCwAAAKBrXQZ2toaGpICd9N4UYJKCW7Zt21bVDh06FL97/fr1VS0FIqWw0BSekkJo0hhPnjzZ9HmltAd2CoObPOlYp6CiiYmJqpaCsFJ/7ty5s+l1pZSydu3aqrZ8+fKqlgLAUnBVCjVM12kKeBsKnEvfw6WV5tkUHpUC4VK/p9DhNH/t3r07jie9dtGiRVWtdZ5tvU6ToftX6vkU7tl6/zNvjyYdr9bwydQj6dyl/kq1FJA5JM29rSGNKXQuvS79lhR+Xkp73+njC2+coMO0Pm2dx9PaY+j8DgUWnyvNz2mM6Xo8fvx4VUvrhKG1cfrudMzSsaDdKAGQqY/T8U89kuaQdD5TLw3d19O6NQWLp78F0/WSgmdbA7/TwyRKKeXgwYNVLV0b6TNb1zO9mtqjBwAAAKY9mxcAAABA12xeAAAAAF2zeQEAAAB0rcvAziQFv6TgqRSAkkIuUxBMCi9MoS2llLJnz56qNm/evKqWgrlaA+Jag8NSbej9wrEurdbznKSeXblyZVVbuHBhVRsKrjp8+HBVS6GbKYAoBf6k0Kz0+9LrRgnmHCUIisnROkenMNpZs2ZVtRTCOUqPjPP+1sC79HnpN5eSQ7PMx5dWOv5pDZHmxHTu0704zZND4cRJWoO0hrKl70l9nN47FLwo9Lsvad5tDQJOvZkCZtPadki6LtJcnNYkadwpdDatR9I6Y2guTtdpmvOtMy6OcYJnU5Bw6pu0phj6ey5J10Fag6fQzPT7rrnmmvP+vBQUWkr+3ekzR7nfTBX+5QUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdG3KBHa2ag2eSgEmp06dqmpDgT+tYTApaGUoCOtcreGHQ2FZqS5Yqz8p3Ced59SzqZdSz86fPz9+d/rM1sCtFLCUjNuHQrP603r+0rlLtRTClQKzhgI303ha59mkNSgsfe9Qv7aG6DF5WuemVEu9mNYAaZ4cZf5L33P69Omm97bO76P0YWvPW2tcOq2BiGmtkOa+FAI41DOp3hoSm9YZqYdbAzfTnD1Ev15a4/Rsa3DlKIHfqe/SZ65atarp81JAbVqXp3DcUcKTx53fpwr/8gIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAujbtAjtbjROaWUp7MFeSQlZaw4KEcM4MrQForcGeQ4E9qWdbv3ucvpuOAUIzXWuPtJ779LpxQjiHxpO0zuWj0PNTV+qbyQrDTFqD58ZZV4wSbmcN0r/W8OR0LsedD1P48jjjaQ2zN+dOba090hr2eTG0BnvOnTu3qo0zP5cyeb+xRzP3lwMAAABTgs0LAAAAoGs2LwAAAICu2bwAAAAAujZjAztbjRL40xpw1fqZQrD4q8YJnxrqJT3GZLsYPXeh59RxgkaZuSYrULs12LA13C5xb5iZepvnWkOa9evMNc48N6R1Pk2hmeP04kwO4RyFowQAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXRPYeQkIFgK4cMypzCT6nelIX9OLCx1c21sQ7lTnX14AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA1y47e/Zs+4svu+xAKWX7xRsOjGTd2bNnl476Jn1MZ/QxU9159XAp+piumIuZDvQx08FgH4+0eQEAAAAw2fxvIwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0LXLR3nx7Nmzz05MTFykocBo9uzZc/Ds2bNLR32fPqYn+pip7ujRo+XUqVOXnc979TG9ON8+1sP0xJqC6eCn9fFImxcTExPlwx/+8IUZFYzpIx/5yPbzeZ8+pif6mKnu4YcfPu/36mN6cb59rIfpiTUF08FP62P/2wgAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF2zeQEAAAB0zeYFAAAA0DWbFwAAAEDXbF4AAAAAXbN5AQAAAHTN5gUAAADQNZsXAAAAQNdsXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA1y6/1AOYqs6ePXvR33vZZZdd0NcBAH260PfycdYpcD7GWd9e6LUxXAqpj/XsheVfXgAAAABds3kBAAAAdM3mBQAAANA1mxcAAABA12xeAAAAAF3ztJGL7Mc//nFVS0m046QsD6XYvuUtbXtTUnCnl4txPlt79mKkhevPmWmU/mp9beqlNE+mWmsfjvKEB0+DmP7GnevGmf9a1x/jzrH6eHobdy5Ofdja6+PM46OwzpiZhvo49UPq41ZvvvlmVXvrW9/a9B2j9PZM6WP/8gIAAADoms0LAAAAoGs2LwAAAICu2bwAAAAAujYjAjtbw4ZSUEoKWRnltanWGvrSGiR3+eX5NLa+dpxwOi6t1Mep5370ox/F94/Tx0kKIEq11HPpdUOvvdDBdlxa48zRpeT+bA16S3NiqqX+HCXUK9VbAxWZusYNO2ydK9PrWu8PqY+H5uNx6O2+tJ6PUeapVB9af5zr6quvbvq8N954o6pdeeWVVW2oh8e5XzC9DIVhpnOfeiz1YurjU6dOVbW0zmids0vJY28Nx53q/MsLAAAAoGs2LwAAAICu2bwAAAAAumbzAgAAAOjatAvsbA0gag2oGgrDTFJQSgpzef3115tqrcFaV1xxRRxPCpe56qqrqto44XT0Z9zwtdZwrhTClfq4NTh2qI9TXfDs1JXOSeu5GwrXag0rHCfEM/Vh+t6hcK0f/vCHVS3dH0YJKuXSaT1PaZ5MvVBKKWfOnGn6zFmzZlW1FBKXejH1XOt3lJLXFUPXJf1oXRu3zptDn5d6IfVM6vX03vnz51e1Y8eOVbV0TQ31cFoPtc7F1hSX1jh/443ywIM0d7auUw4cOFDV5syZU9V27NhR1ZYtW1bVTp48GceY+rv1b7epvl52xwEAAAC6ZvMCAAAA6JrNCwAAAKBrNi8AAACArk3pwM5xArNSLQUIpVopOdwnBQal0JdUaw1JHCVwJgXEpO9OQV/TMeBlKmk9/ikIK53P2bNnx+9JAa6pF48fP17VDh8+XNUOHTpU1U6cOBG/+1xDgZ3p96SgovR+wbOTJx3X1vDY1MfpHM+dOzd+d3pt+u4UKHvq1KmqlubyUebeJL02jTHdc9LrWoPLGF/rWiOtC06fPl3VhubEo0ePVrXUs2k+X7JkSdPr0uelMQ7NxwsWLGj6HiGel844c0Pr2mMomDh9d+qltKZIQYcrVqyI33OuXbv+f+3dW6udV7kH8OGNStoczEqymjY1y9jWmpaqxRZasIJeiCD4CfTCW2+8EPwCIiJ+BS+KF4IWRPCIFA+hDSgFDzVYTNukaXNo0qZJmlZF6L5wb9hk/Mfez3RmrTVW8vtdPsw533e+7zPGHGuQ/N9XulpaA7eWx0r6myBJ36X628dirvcDGNJ6dxTqmtYaaX5PAZsvvPBCV1tZWelqu3bt6mrpt2F1dTWe4+nTp7ta6vk0v2/1/vTrAgAAAEzN5gUAAAAwNZsXAAAAwNRsXgAAAABT2zKBnSm4pVpLYUMppCUFnYxCq6pBbSl87c033+xqKagrBbeksK0ULtdaDhRL0vVJtdG1uNZWD4KZQbp3qZbufeqbUbhWqldD565evVqqjfrzWilMqbXWtm/f3tXStUjjV/Ds5qoGaaW5ZZHg2TSfp95O82eqpTk6fZd03FEAWPVapP6szuWsj7SuSAF/ae6shsSO6mlOTcdO4W87duwovS6FL6fjtpa/YxqrqberwafUXe9wzmqg8iKBrKkPUxDn8ePHu1r6focOHepq6RxTiGdr+XundUYaA+l8rB+Wt0wfV/9eSfNU6pvRa9M5vvTSS6Vj//SnP+1q999/f1d7+umnu9pdd90VzzGtrdPfkrt37y69d3QtrjVDv/uXFwAAAMDUbF4AAAAAU7N5AQAAAEzN5gUAAAAwtSkDO6tBnCmQLYWQpMCsFECYailws7UcmJWkYM8UiJSk77dI4FUK1krfJwUlpuCWdN7V78JYun/p3lfDXy9dutTVUohPazmQKvXNMiFV1UDYFJDUWr4+qe+qY22RoDGWk+5d6uPUcyl49syZM+XjpHk/fWYaL+m9qb927tzZ1VZWVuI53nrrrV0tjSEBhltXNTgu9UJrucfSa9NnplC2tbW1rrZnz56uln4fXn755XiO6TcjhdSmNURaN6U1W3UNeLO53uGcqY/SejD1YAq4bK0ekJ8CO1Ptueee62qp1+++++6u9vvf/z6eY1rrp89M16ca5szYMuO7GjJb7ePR73Wav+67776u9vzzz3e1O++8s6ul/krrjC9/+ctd7amnnorn+LGPfayr/fnPf+5qaaymdVhae8za21bxAAAAwNRsXgAAAABTs3kBAAAATM3mBQAAADC1KQM7k2qYSwoL2rZtW1fbsWNHV0sBL6MQwVRP4T5JNUguhWilcLkUoNVaDn2svi4Ft1RDdmYNeJlVChtKvZRCd+64446ulsKxRn2cjpPu/VtvvdXVXnvtta529uzZrnb+/Pmulnp7FFSY+jMFPKYwuPTedL317PLS/Uv3JM1/KQTt8uXLpVpreQ5MoWzp2KmW+iaNqxR+uH///niOKYwujenUn+be9VG9XtXg3xTylkLiRqHBqZ4CLdP8d8stt3S11LP79u0r1VJ4aGutvfTSS6XzSdc2fWaaI4RzXn/VdUZaK6TeSmvo1vI9TuvW06dPd7V030+ePNnVUoBhCi9M6+rWcqhhCllM66vU69UA8Zttfl52HKf3VwPgqw8dGM1z6dipZ9M9/cEPftDVUnjy448/3tUefvjhrnbs2LF4jql+8ODBrpbClw8cONDV0houXccZ+ti/vAAAAACmZvMCAAAAmJrNCwAAAGBqNi8AAACAqW1qYOcozCXVU5BICrJK4WspuC0FEKb3pmO0lgNLUrBJCjpKIW0pJCmF0KT3joJCU7BQNeSteg+q4XIzBLzMqhpslgJlUz+kIK1RuFYKs03nk8ZGtRerAUtpTC6iGmoo/HB9VOeMFND3j3/8o6tV5+3WcuBnmv9SLc3x1Voymo/T+E3jPP0W6MXlVa9hmpuqYYdpDZDu5yJB4Gm8VEOQT5061dXSON25c2dXS3P+6DgpSDcFlaYavWWDDlOvp75eJrAz/f63lnspvf/ixYtdbffu3V3tE5/4RFf72c9+1tVSX95///3xHFMg87lz57paug/p+qTfBmuKseoarKo6Z6d7l+bs1lpbXV3tammdcd9995WOk87nm9/8Zlf77W9/29W+8Y1vxHN84oknutpHPvKRrnbixImutswDHWbgX14AAAAAU7N5AQAAAEzN5gUAAAAwNZsXAAAAwNRsXgAAAABT29SnjSwrJcymRPeU/JqSZKspy63l1Oz02nQ+6bxTWnFK1k+p3qnWWmtXrlzpainVP6k+IYLFpETl6r0/e/ZsV0vpx6l29erVeD7p6QspEfu9731vV0tPKkn9Xn2aSvq80ftTQnTqT+ne6yNd15SmXU24T/NpmqPT00tay+MqpWSnfk/z54ULF7rapUuXSscYGZ37tarXMX3esk8puNks81SGNF+lJzCkpy+kWmt5HKT7nObj9Ht/8uTJrpaeqrBv377ScVvLT3V49dVXu1p13ZW+s3m7rvpUi+qcnXo9/a6PntKQnmy2Z8+erpb6Ix37U5/6VOkYf/rTn7raoUOH4jkePny4q6WnPKS1WerXtOZKTwli7Hr/dlWfaDL6myg9DSf93v/qV7/qaqlHvvvd73a1Bx98sKv9+Mc/7mpHjx6N57hr166u9tRTT3W1Rx55pKul9Uz6Haj+LbjRc7a/RgEAAICp2bwAAAAApmbzAgAAAJiazQsAAABgalMGdqZQlRQeVQ06fPvtt7va3//+91JtFLqTAktSgNf73ve+rpZCUVZWVrpaNRQ0hR+2lgOVUnBjNcRTiNbGSdc6hVml0Kv03hS41VoeVynEqxpmm4Lk0vmksZvCFEevTeMv9Xs1uExvj13v8LfUSynoMNVSUFtrea5M/ZB6LIUNvvjii13thRde6Grnz5+P55Ok8ZKuRaql38T0XYR4Lq/a26m/0r1LvTnq4xTkmcZQqqXg2dSfKagtfZcUsthaDt1MvZjWFWkuTyF4ozXNzW4jQg3THJLuUVovt9baa6+91tXSGEh9+Oyzz3a1NCZSH/3mN7/pak8++WQ8x8cee6yrvf76613tzJkzXe3AgQNdLa3907WdIehwq6sGcVZDvEfBs2kc3H777V0t3b/Us1/5yle62rFjx7rad77zna72+OOPx3P8/Oc/39V+/etfd7U0/tLfoSl4NvXsDGsK//ICAAAAmJrNCwAAAGBqNi8AAACAqdm8AAAAAKa2pVORUohWCkVLwW8pwLAatjX6zBTSkl6Xwn1SQFUKjEnhoymoq7XWLl68WDpOCmlJgUgzhLRsdSn8Jt2TFOiWenHXrl1dbffu3aVaazlQNvVnOu/Uiyn0KgUinjt3rquloK/WWrty5UpXq4bMpmsrIGt9pOuarn8KdU29nXo2BRu3lvt4NHdf67bbbutqaS5Pvy2nTp3qaikUubX6906vS0Fj1RDPxFy+vGqw4SLhxKmeAuXSOLjrrru6WpqjX3nlla6W+v3QoUPxHNPaKQXZpbGRAtDTOq46R+vjumqAYTV8NYXGjj4z1dI6I33miRMnulrq9YcffrirjQI7X3755a529913d7V0LVJQafrbIa2Z+LfquF0miLP6QIcUHNta7sW0Rk2v+8lPftLV0nz6ve99r6s9/fTTXS39Lddaaz//+c+72qc//emuduTIka720Y9+tKul37S0Hklz9kYzugAAAICp2bwAAAAApmbzAgAAAJiazQsAAABgals6sDMFsqQwnRRalWrpvSlgqrUcxpMC3fbs2dPVDhw40NXuuOOOrrZ3796uVg19a60eKFYNg0uvYzHV61rtzzfeeKOrpTCqFPo2qqfwqVRLvZjGRfp+KfQthduOpMCgah8L7Fwf6fqnoLd0T6q9ffr06XjsFP6W5uPUx6mX0ryf5tkUnDgKsktjI722GoaV+jjVhBouphr+luboJL03hWS3lgOP07yYAp3TnJrCaFMIYTX8vLXW9u/f39VS4GcK6z179mxXG62xrqWP65YJNUxzcerX0e9omtPSPU7r2wceeKCr/eUvf+lqKcz5i1/8YldbW1uL55jCZD/0oQ91tdTrx48f72rVdYYeHkvXJv0Nk65rNXi2GuLZWg4BT8dOofmPPfZYV0vrmW9/+9td7Yc//GFX++pXvxrP8Yknnuhq99xzT1dLYaHptyb9PVANx99o/uUFAAAAMDWbFwAAAMDUbF4AAAAAU7N5AQAAAExtSwd2pmCgFBKVAq+qQYWjMMwUmJVCq6q1FI6Vvl8Kprl69Wo8x6QaaJpCWlJ4jgCisXRtqkFa6fqn0KwUAnTx4sXS61rL9z4FC6bwohQ8e/Dgwa62urra1dK4SmO3tRwMmnox9baeXV61j6tBnClIqxqqPArXSvc5zfEpXCsFx6V+T/2ZjpvGT2v1cZ5UrzeLqV7DdJ9SH1+5cuW6Hre1eh+ndU4af+n34fLly11tNNbSZ1aDcNPYqIbykS0zN6S+XmY90lq+x2kuT+vbtC547rnnutovfvGLrvbQQw91tVEfHTlypHScw4cPd7XqOiMF6FZDlhmrBs9Wr+voNzjN5WkN8Mc//rGrpQc1/PKXv+xqKUjz2LFjXe3JJ5+M5/jggw92tR/96Edd7TOf+UxXS4Gd+/bt62rpO8/Qs/7lBQAAADA1mxcAAADA1GxeAAAAAFOzeQEAAABMbUsHdqbglhSmk4KnUoBQem81UK211rZt29bVUnBLCjpcW1srvS6FfY7CU1IgUgr/qgZrpeOkYKgZwlxmUA1nStc6hT2le5/6JgXspF4YHScFZKbeTiFt6b3p+6WApVEAWOqxFJZXDYNjfaRr/a9//aurpfk4hUelYMH0utbGvXOtFLR85513drX3v//9XS2FJCbpd6S13LNp7k3jKo1fIZ7ro9rH6X5W1x+jkO1UT3NlmmfTWiP1UhpXp0+f7mqpN1tr7cUXX+xqH/jAB7pa+q2rBkRW1x9kaR5IPZxqaW28iNQ36TNTr6ceTmH26b2/+93vutqjjz4azzEFJaa+vnDhQldL67DU19bG66Pa29Vw/FQbSfc+hXunMfCFL3yhq/3hD3/oal//+te72ve///14Pp/85Ce72r333tvV0ni57bbbuloK9k/fZYZ1hn95AQAAAEzN5gUAAAAwNZsXAAAAwNRsXgAAAABTmzKwsxpqmELMUrjIrbfeWnpvCi9MYUGjz0xhcCngJdW2b9/e1VLYVroOo4C4FNxYDZGsBgsJIFpe6tnUn6kXqwFCKysr8dgphDD1dgp6TaE9KbjqypUrXS0FA43CcatBsSlob4ZgoZtFdY5OfZzem0IJ0xzbWp4D071Pc+ru3btLr0vjNIUppoDG1nJoVjXUMI3JNL8nxsBYNfQ0hbpV57pFgmdTPYXRpvGyd+/errZ///6ulnou9ebly5fjOaaeT3Pv6upqV9OLG6Paw9UQz9TrqQ9aq6/f05x96dKlrvbAAw90tX379nW1kydPdrUUvNxaa4888khXO3r0aFdLc3laq6ffhnQdrZf/bZm/OdJck2qpP9O4WCQo/tSpU10trWf+9re/dbWDBw92tWeffbarPfPMM10thWu21trXvva1rva5z32udD733HNPV0vjNKm+bj1t/hkAAAAA/B9sXgAAAABTs3kBAAAATM3mBQAAADC1KQM7k2po3z//+c+u9vbbb3e1FMSTXjcKEUxhPCnUMAUiphCtFOZy4MCBrpbC5VJYUGv5+6QQm/RdUgAOy0s9m+5JCrNKYW7Hjx/vatXeHh07SeGJKRg0hcZVAxFHYW7p3FPPVsP3EkFai6mGsqVQyWogbDVUeXScNC8uEzRVHZMj6bcpzbPpHNP1qd4D1kd1zqiGCy/y2mqAaBoXKfxtz549Xe3VV1+N51gd59XxV53LWU41xDPNcynQdRR0mH6v01hJa48ULHjhwoWutra21tVOnDjR1Z5//vl4jo8++mhXS+Pn3LlzpdeNfpfYGKmPq7XRGrgawpped++993a1FOb8pS99qasdOXKkq332s5+N5/jBD36wq6W19e23397V0rhKfTxr8KyVDgAAADA1mxcAAADA1GxeAAAAAFOzeQEAAABMzeYFAAAAMLVNfdrIIoml6bUp4TqlWaf01ZSunRLd01MWWmtt27Ztpdott9xSqqX3pmOn7zd6Ikr1qRMpbTel8jKfanpyShBvLaeIp3T7NDbSsatjOj1xYvSkhPSUhvQd03mnhPUZkpJvRNU5OiVab9++vaulp9mkpzeN3p96NvVIGhspGTw9WSTNsaPk+eoYGj09iuUs8+Shah+n3/bqE2Vay2uV9JudvsuOHTu62urqalc7dOhQV0vnPXqSzhtvvNHV0pOBUi1J16c6l99sqr9d6XXV9y67prh8+XJXS08sSGMqzafpCSRpbbyyslJ6b2utHTt2rKtVx0X6LqnXPflpMdWnZ1WfhFh9ks7o76dRf1/r5MmTXS314tmzZ0u11Evf+ta34rHTU3OeeeaZrvbhD3+4q1WfIjJrH895VgAAAAD/zeYFAAAAMDWbFwAAAMDUbF4AAAAAU9vUwM5FVAOIUqhTCmRJIYApLCi9rrUcYJTOJwUL7dy5s6vt3bu3q6VQ0RTKNQp4S4Ezb775ZldL3zFdR4FZy6v2cQqzSiGX+/fv72opZCq9t7UcFJuC6KrBSamXUuBcGmspPLS1HCyUwpiEc26u1A/p3qX5ON2narhmazlEMI2h9JlpLk/nmPo49eEo5DnN3dUgu1TT28urriHSb2x1nkwhnCmMtrX6XFcNAU0Bt6k/FwlQTtJ4SeMqsa7ojcb2MqGzqZb6ujr/jAJZ07hIx07jIq2Dk7TGOXz4cFdbW1uL70+houkz0zmmNbS5OFv2ulQDJFMfp9ctcj7VsZZ+19P8/PGPf7yrXbhwoas99NBDXS2FgraWx0sKC009m9b+1RDPGfiXFwAAAMDUbF4AAAAAU7N5AQAAAEzN5gUAAAAwtSkDO6sBISmQJYUIVcMPU0Bmeu/oONVjV1+XQmhSMFYKWWkth9ulWgrWEqK1uarBgtXQzBTY01q976rBdul8qkGOoz5O3yd9ZtWsAURbSXV+SGGDqZbCMF9//fWuNrrv1QDXaqhrGhfvfve7S68bBSinQLh03smy4WNky4T8LhJieK1Rj1Tvc3VOTd8v/RZUx+noOKlWDRWt/raQVfs19Vy6zinQdZH7kY6T1p2pF9Kx0+suXrzY1VKo4SioPPVrCk9MgZ3VfjU/L6Yazpmk65/mrzQ/j+a5VE99nD4zve7MmTNdLX2/o0ePdrUUzN9aa3/9619Lr60+YGIr9ax/eQEAAABMzeYFAAAAMDWbFwAAAMDUbF4AAAAAU5sysDNZJkgkhbmkwJ4U0JKCTlrLYVTpOCmQJQV9vec97ynVUjjMKNSmGupV/S5snGrPpgDX1LMp9HL02lFw5rVS31X7OIUfjkLsqrZS2NDNrBqutR59XJ2jU3BcOsf0ulHIc6qnY5t7N9f1Dt+rBnSP6tUeqY6X9JuRaousK673+oxsmetcXYumY6Tf5lE4bQrJrIaNV9fG1dDntM5orT6/p98Q4cnLWyb0tNrHySLvTX03CoC9Vuq71O8rKytdLc3Z27dvj8dJIeDpOCl49nrP4xvNv7wAAAAApmbzAgAAAJiazQsAAABgajYvAAAAgKltmcDOpBouksKGquGA27ZtKx+7WltGNUyxtRyAU62xuaq9lAKIUpBWCuzZKNUxMHqd/ryxVAPh0utG4VopfCrVqueTaqOAuv/0uGxt1XkphRWO3ptCA0fBmdeqBm+vx7pg2bBlrq9l1sap3xYJ7FymD6vzbjXEdtSX6f3m7c11vcNoU98s8rue5uLqOqM6H6ZwznQ+b731Vnx/NRh0I/423Wj+5QUAAAAwNZsXAAAAwNRsXgAAAABTs3kBAAAATG1LB3Ym1RCSahjVRoX4LBtqCP+jGuw5eu0yquNKCCf/WzXEczODAatjRfDbjWeZ+Sq9N4V4trYx87E5+ua0TG9Vgz0XUe2vZcIGR8cwR29d1X5I9z6FYY56ZJHXVlRDZhcZV9V1043Iv7wAAAAApmbzAgAAAJiazQsAAABgajYvAAAAgKndcIGdVQIyuVEtE9IGW9FGzNPGEP+fZcMw9TGbzdqYG8EyQa+tbcw8uWzo7c3MlQMAAACmZvMCAAAAmJrNCwAAAGBqNi8AAACAqd20gZ0A3BiEEHIj0McAm08g7dz8ywsAAABgajYvAAAAgKnZvAAAAACmZvMCAAAAmJrNCwAAAGBqNi8AAACAqdm8AAAAAKZm8wIAAACYms0LAAAAYGo2LwAAAICp2bwAAAAApmbzAgAAAJiazQsAAABgajYvAAAAgKnZvAAAAACmZvMCAAAAmJrNCwAAAGBqNi8AAACAqdm8AAAAAKZm8wIAAACY2rveeeed+ovf9a7zrbWT63c6sJCD77zzzt5F36SPmYw+Zqv7j3q4NX3MVMzF3Aj0MTeCYR8vtHkBAAAAsNH8txEAAABgajYvAAAAgKnZvAAAAACmZvMCAAAAmJrNCwAAAGBqNi8AAACAqdm8AAAAAKZm8wIAAACYms0LAAAAYGr/BTE+s8ZjjV04AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(6, 6, figsize=(15, 15))\n", + "for axis, ims in zip(axes, plot_images):\n", + " for ax, im in zip(axis, ims):\n", + " ax.imshow(center_and_crop_image(im, xs[i], ys[i]), cmap='gray', vmin=-2, vmax=2)\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "fig, axes = plt.subplots(len(keys), 2, figsize=(10, len(keys)*4))\n", + "for psi_act, lambda_act, axis in zip(all_psi_acts, all_lambda_acts, axes):\n", + " im = axis[0].imshow(psi_act / psi_act.max())\n", + " axis[0].set_xlabel('Component 1 phase', fontsize=14)\n", + " axis[0].set_ylabel('Component 2 phase', fontsize=14)\n", + " axis[0].set_xticks(np.arange(20)[::3])\n", + " axis[0].set_xticklabels(np.round(psi_values[::3], 2))\n", + " axis[0].set_yticks(np.arange(20)[::3])\n", + " axis[0].set_yticklabels(np.round(psi_values[::3], 2))\n", + " divider = make_axes_locatable(axis[0])\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax)\n", + "\n", + " im = axis[1].imshow(lambda_act / lambda_act.max())\n", + " axis[1].set_xlabel(r'$\\log_2(\\mathrm{Component\\/1\\/SF})$', fontsize=14)\n", + " axis[1].set_ylabel(r'$\\log_2(\\mathrm{Component\\/2\\/SF})$', fontsize=14)\n", + " axis[1].set_xticks(np.arange(20)[::3])\n", + " axis[1].set_xticklabels(np.round(lambda_values[::3], 2))\n", + " axis[1].set_yticks(np.arange(20)[::3])\n", + " axis[1].set_yticklabels(np.round(lambda_values[::3], 2))\n", + " divider = make_axes_locatable(axis[1])\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax)\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 328, + "metadata": {}, + "outputs": [], + "source": [ + "lambda_values = np.linspace(1, 5, 20)\n", + "f_ratio_values = 1/ (fori_values / fori_values[::-1])\n", + "rot_values = np.linspace(-90, 90, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 329, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "fig, axes = plt.subplots(3, len(keys), figsize=(len(keys)*5, 12))\n", + "for act, axis in zip(all_psi_acts, axes[0]):\n", + " im = axis.imshow(act / act.max())\n", + " axis.set_xlabel('Component 1 phase', fontsize=14)\n", + " axis.set_ylabel('Component 2 phase', fontsize=14)\n", + " axis.set_xticks(np.arange(20)[::3])\n", + " axis.set_xticklabels(np.round(psi_values[::3], 2))\n", + " axis.set_yticks(np.arange(20)[::3])\n", + " axis.set_yticklabels(np.round(psi_values[::3], 2))\n", + " divider = make_axes_locatable(axis)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax)\n", + " \n", + "for act, axis in zip(all_lambda_acts, axes[1]):\n", + " im = axis.imshow(act / act.max())\n", + " axis.set_xlabel(r'$\\log_2(\\mathrm{Component\\/1\\/SF})$', fontsize=14)\n", + " axis.set_ylabel(r'$\\log_2(\\mathrm{Component\\/2\\/SF})$', fontsize=14)\n", + " axis.set_xticks(np.arange(20)[::3])\n", + " axis.set_xticklabels(np.round(lambda_values[::3], 2))\n", + " axis.set_yticks(np.arange(20)[::3])\n", + " axis.set_yticklabels(np.round(lambda_values[::3], 2))\n", + " divider = make_axes_locatable(axis)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax)\n", + " \n", + "for act, axis in zip(all_fori_acts, axes[2]):\n", + " im = axis.imshow(act / act.max())\n", + " axis.set_xlabel('f_ratio', fontsize=14)\n", + " axis.set_ylabel(r'$\\Delta Orientation$', fontsize=14)\n", + " axis.set_xticks(np.arange(20)[::3])\n", + " axis.set_xticklabels(np.round(f_ratio_values[::3], 2))\n", + " axis.set_yticks(np.arange(20)[::3])\n", + " axis.set_yticklabels(np.round(rot_values[::3], 2))\n", + " divider = make_axes_locatable(axis)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax)\n", + "\n", + "fig.tight_layout()\n", + "fig.savefig('/src/static-networks/my_notebooks/Figures/high_low/high_low_tuning.png')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.2 , 0.25274725, 0.31034483, 0.37349398, 0.44303797,\n", + " 0.52 , 0.6056338 , 0.70149254, 0.80952381, 0.93220339,\n", + " 1.07272727, 1.23529412, 1.42553191, 1.65116279, 1.92307692,\n", + " 2.25714286, 2.67741935, 3.22222222, 3.95652174, 5. ])" + ] + }, + "execution_count": 221, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lambda_values / lambda_values[::-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", + "for ax, im, act in zip(axes.ravel(), images, acts):\n", + " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", + " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", + "for ax, im, act in zip(axes.ravel(), images, acts):\n", + " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", + " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", + "for ax, im, act in zip(axes.ravel(), images, acts):\n", + " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", + " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(values, acts)" + ] + }, + { + "cell_type": "code", + "execution_count": 457, + "metadata": {}, + "outputs": [], + "source": [ + "thetas = np.linspace(bounds['lower_edge_theta'], bounds['upper_edge_theta'], 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 459, + "metadata": {}, + "outputs": [], + "source": [ + "param['edge_theta'] = thetas[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [], + "source": [ + "groups, neurons, masks, meis, mei_acts, optcps, optcp_acts, optcp_params = (base.MEIMask * zd_deis.MaskFixedMEI * high_low.OptimalCombPlaid & 'search_range = 3 and best_activation < activation').fetch('group_id', 'neuron_id', 'mask', \\\n", + "'mei', 'activation', 'best_image', 'best_activation', 'best_params', order_by='group_id, neuron_id')" + ] + }, + { + "cell_type": "code", + "execution_count": 426, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "46" + ] + }, + "execution_count": 426, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groups[sorted_idx[3]]" + ] + }, + { + "cell_type": "code", + "execution_count": 427, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6369" + ] + }, + "execution_count": 427, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "neurons[sorted_idx[3]]" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [], + "source": [ + "act_ratios = optcp_acts / mei_acts" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [], + "source": [ + "sorted_idx = np.argsort(act_ratios)" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(act_ratios, stat='probability')\n", + "plt.xlabel('OCP activation / MEI activation')\n", + "sns.despine()" + ] + }, + { + "cell_type": "code", + "execution_count": 414, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8871019177769498" + ] + }, + "execution_count": 414, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "act_ratios[sorted_idx[800]]" + ] + }, + { + "cell_type": "code", + "execution_count": 416, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "138" + ] + }, + "execution_count": 416, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(act_ratios > 1).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 423, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 423, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(meis[sorted_idx[3]])" + ] + }, + { + "cell_type": "code", + "execution_count": 424, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 424, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(optcps[sorted_idx[3]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [], + "source": [ + "mei, mei_act, mask, mask_x, mask_y = (zd_deis.MaskFixedMEI * base.MEIMask & 'group_id = 88 and neuron_id = 2588').fetch1('mei', 'activation', 'mask', 'mask_x', 'mask_y')" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 236, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(mei)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "rel = (zd_deis.DEIGoodRun & 'diverse_params = 62 and threshold_params = 1 and mei_params = 8 and mask_params = 2').proj()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "04-04-2021:23:55:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "04-04-2021:23:55:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "04-04-2021:23:55:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "04-04-2021:23:55:51 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", + "04-04-2021:23:55:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "04-04-2021:23:55:51 INFO configs.py 377:\t Using statistics source all\n", + "04-04-2021:23:55:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "04-04-2021:23:55:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "04-04-2021:23:55:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "04-04-2021:23:55:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "04-04-2021:23:55:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", + "04-04-2021:23:55:51 INFO configs.py 351:\t Found 4472 active trials\n", + "04-04-2021:23:55:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "04-04-2021:23:55:51 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", + "04-04-2021:23:55:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "04-04-2021:23:55:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "04-04-2021:23:55:51 INFO configs.py 806:\t Setting cuda=False\n", + "04-04-2021:23:55:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "04-04-2021:23:55:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "04-04-2021:23:55:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "04-04-2021:23:55:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "04-04-2021:23:55:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/src/static-networks/staticnet_invariance/high_low.py:200: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /pytorch/torch/csrc/utils/tensor_numpy.cpp:143.)\n", + " mask = torch.as_tensor(mask, dtype=torch.float32, device='cuda')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "04-04-2021:23:55:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "04-04-2021:23:55:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "04-04-2021:23:55:51 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", + "04-04-2021:23:55:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "04-04-2021:23:55:51 INFO configs.py 377:\t Using statistics source all\n", + "04-04-2021:23:55:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "04-04-2021:23:55:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "04-04-2021:23:55:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "04-04-2021:23:55:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "04-04-2021:23:55:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", + "04-04-2021:23:55:51 INFO configs.py 351:\t Found 4472 active trials\n", + "04-04-2021:23:55:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "04-04-2021:23:55:51 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", + "04-04-2021:23:55:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "04-04-2021:23:55:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "04-04-2021:23:55:51 INFO configs.py 806:\t Setting cuda=False\n", + "04-04-2021:23:55:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "04-04-2021:23:55:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "04-04-2021:23:55:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "04-04-2021:23:55:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "04-04-2021:23:55:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "04-04-2021:23:55:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "04-04-2021:23:55:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "04-04-2021:23:55:52 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", + "04-04-2021:23:55:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "04-04-2021:23:55:52 INFO configs.py 377:\t Using statistics source all\n", + "04-04-2021:23:55:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "04-04-2021:23:55:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "04-04-2021:23:55:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "04-04-2021:23:55:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "04-04-2021:23:55:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", + "04-04-2021:23:55:52 INFO configs.py 351:\t Found 4472 active trials\n", + "04-04-2021:23:55:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "04-04-2021:23:55:52 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", + "04-04-2021:23:55:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "04-04-2021:23:55:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "04-04-2021:23:55:52 INFO configs.py 806:\t Setting cuda=False\n", + "04-04-2021:23:55:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "04-04-2021:23:55:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "04-04-2021:23:55:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "04-04-2021:23:55:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "04-04-2021:23:55:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", + "04-04-2021:23:55:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", + "04-04-2021:23:55:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", + "04-04-2021:23:55:52 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", + "04-04-2021:23:55:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", + "04-04-2021:23:55:52 INFO configs.py 377:\t Using statistics source all\n", + "04-04-2021:23:55:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", + "04-04-2021:23:55:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", + "04-04-2021:23:55:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", + "04-04-2021:23:55:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", + "04-04-2021:23:55:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", + "04-04-2021:23:55:52 INFO configs.py 351:\t Found 4472 active trials\n", + "04-04-2021:23:55:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", + "04-04-2021:23:55:52 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", + "04-04-2021:23:55:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", + "04-04-2021:23:55:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", + "04-04-2021:23:55:52 INFO configs.py 806:\t Setting cuda=False\n", + "04-04-2021:23:55:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", + "04-04-2021:23:55:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", + "04-04-2021:23:55:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", + "04-04-2021:23:55:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", + "04-04-2021:23:55:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", + "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", + "Optimizing with seed = 0\n", + "Optimizing with seed = 1\n" + ] + }, + { + "ename": "TypeError", + "evalue": "conv2d(): argument 'input' (position 1) must be Tensor, not numpy.ndarray", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhigh_low\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOptimalCombPlaid\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/datajoint/autopopulate.py\u001b[0m in \u001b[0;36mpopulate\u001b[0;34m(self, suppress_errors, return_exception_objects, reserve_jobs, order, limit, max_calls, display_progress, *restrictions)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_allow_insert\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m \u001b[0mmake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 155\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSystemExit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/static-networks/staticnet_invariance/high_low.py\u001b[0m in \u001b[0;36mmake\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0mtensor_params\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbest_params\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'cuda'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 259\u001b[0m \u001b[0mbest_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptcp_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensor_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 260\u001b[0;31m \u001b[0mbest_activation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbest_image\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 261\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 262\u001b[0m \u001b[0mks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'edge_center_x'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'edge_center_y'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'edge_theta'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'theta1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'angle1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Lambda1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sigma1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'psi1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gamma1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'theta2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'angle2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Lambda2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sigma2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'psi2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gamma2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/featurevis/featurevis/models.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,\n\u001b[0m\u001b[1;32m 65\u001b[0m self.neuron_idx] for m in self.models]\n\u001b[1;32m 66\u001b[0m \u001b[0mresps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresps\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# num_models x batch_size x num_neurons\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/featurevis/featurevis/models.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,\n\u001b[0m\u001b[1;32m 65\u001b[0m self.neuron_idx] for m in self.models]\n\u001b[1;32m 66\u001b[0m \u001b[0mresps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresps\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# num_models x batch_size x num_neurons\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/static-networks/staticnet/base.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, readout_key, behavior, eye_pos)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreadout_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0meye_pos\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshifter\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshift\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/static-networks/staticnet/cores.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_)\u001b[0m\n\u001b[1;32m 157\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeat\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0mdo_skip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ml\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mskip\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m \u001b[0minput_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mdo_skip\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mskip\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 160\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/src/static-networks/staticnet_analyses/utils.py\u001b[0m in \u001b[0;36mnamed_forward\u001b[0;34m(self, input, name)\u001b[0m\n\u001b[1;32m 451\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnamed_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 452\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmod_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_modules\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 453\u001b[0;31m \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 454\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod_name\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 455\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 399\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_conv_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 401\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mConv3d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_ConvNd\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36m_conv_forward\u001b[0;34m(self, input, weight, bias)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstride\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 394\u001b[0m _pair(0), self.dilation, self.groups)\n\u001b[0;32m--> 395\u001b[0;31m return F.conv2d(input, weight, bias, self.stride,\n\u001b[0m\u001b[1;32m 396\u001b[0m self.padding, self.dilation, self.groups)\n\u001b[1;32m 397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: conv2d(): argument 'input' (position 1) must be Tensor, not numpy.ndarray" + ] + } + ], + "source": [ + "high_low.OptimalCombPlaid.populate(rel)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "key = (high_low.OptimalCombPlaid.key_source & rel.proj() & 'group_id = 46 and neuron_id = 879').fetch1('KEY')" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [], + "source": [ + "images = []\n", + "for l in lams:\n", + " params = torch.as_tensor([0, l, 3, 0, 1], dtype=torch.float32, device='cuda')\n", + " image = generator.gen_gabor(*params).cpu().detach().squeeze().numpy()\n", + " images.append(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", + "for im, ax, l in zip(images, axes.ravel(), lams):\n", + " ax.set_title(l)\n", + " ax.imshow(im, cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", + "for im, ax, l in zip(images, axes.ravel(), lams):\n", + " ax.set_title(l)\n", + " ax.imshow(im, cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", + "for im, ax, l in zip(images, axes.ravel(), lams):\n", + " ax.set_title(l)\n", + " ax.imshow(im, cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/featurevis/.ipynb_checkpoints/models-checkpoint.py b/featurevis/.ipynb_checkpoints/models-checkpoint.py new file mode 100644 index 0000000..96362b7 --- /dev/null +++ b/featurevis/.ipynb_checkpoints/models-checkpoint.py @@ -0,0 +1,114 @@ +import torch + +from featurevis.utils import varargin + + +class Ensemble(): + """ Average the response across a set of models. + + Arguments: + models (list): A list of pytorch models. + readout_key (str): String identifying the scan whose neurons will be outputted by + the model + eye_pos (torch.Tensor): A [1 x 2] tensor with the position of the pupil(x, y). + This shifts the FOV of all cells. Default (None) is position at center of + screen (i.e., it disables the shifter). + behavior (torch.Tensor): A [1 x 3] tensor with the behavior parameters + (pupil_dilation, dpupil_dilation/dt, treadmill). Default is to return results + without modulation. + neuron_idx (int or slice or list): Neuron(s) to return. Default returns all cells. + y_shift, x_shift (float or torch tensor): Overwrite the learnt (per-cell readout) + shift with these values for all cells. Values are clipped to [-1, 1] (see + torch.nn.functional.grid_sample). Default uses the learnt readout shift. + average_batch (boolean): If True, responses are averaged across all images in the + batch (output is a num_neurons tensor). Otherwise, output is a num_images x + num_neurons tensor. + device (torch.Device or str): Where to load the models. + + Note: + We copy the models to avoid overwriting the gradients (and grid if x_shift or + y_shift is set) of the original models. You can access our copy of the models as + my_ensemble.models. + """ + def __init__(self, models, readout_key, eye_pos=None, behavior=None, + neuron_idx=slice(None), y_shift=None, x_shift=None, + average_batch=True, device='cuda'): + import copy + self.models = [] + for m in models: + m_copy = type(m)(core=m.core, readout=m.readout, modulator=m.modulator, nonlinearity=m.nonlinearity, shifter=m.shifter) + m_copy.load_state_dict(m.state_dict()) + self.models.append(m_copy) +# self.models = [copy.deepcopy(m) for m in models] + self.readout_key = readout_key + self.eye_pos = None if eye_pos is None else eye_pos.to(device) + self.behavior = None if behavior is None else behavior.to(device) + self.neuron_idx = neuron_idx + self.y_shift = y_shift + self.x_shift = x_shift + self.average_batch = average_batch + self.device = device + + for m in self.models: + # If needed, change readout shifts to the desired ones + with torch.no_grad(): + if self.y_shift is not None: + m.readout[readout_key].grid[..., 1] = self.y_shift + if self.x_shift is not None: + m.readout[readout_key].grid[..., 0] = self.x_shift + + m.to(device) + m.eval() + + def __call__(self, x): + resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:, + self.neuron_idx] for m in self.models] + resps = torch.stack(resps) # num_models x batch_size x num_neurons + resp = resps.mean(0).mean(0) if self.average_batch else resps.mean(0) + + return resp + + +class VGG19Core(): + """ A pretrained VGG-19. Output will be intermediate feature representation + (N x C x H x W) at the desired layer. + + Arguments: + layer (int): Index (0-based) of the layer that will be optimized. + use_batchnorm (boolean): Whether to download the version with batchnorm. + device (torch.Device or str): Where to place the model. + """ + def __init__(self, layer, use_batchnorm=True, device='cuda'): + from torchvision import models + + vgg19 = (models.vgg19_bn(pretrained=True) if use_batchnorm else + models.vgg19(pretrained=True)) + if layer < len(vgg19.features): + self.model = vgg19.features[:layer + 1] + else: + raise ValueError('layer out of range (max is', len(vgg19.features)) + self.model.to(device) + self.model.eval() + + @varargin + def __call__(self, x): + return self.model(x) + + +class VGG19(): + """ A pretrained VGG-19. Output will be the average of one channel across spatial + dimensions. + + Arguments: + layer (int): Index (0-based) of the layer that will be optimized. + channel (int)_: Index (0-based) of the channel that will be optimized. + use_batchnorm (boolean): Whether to download the version with batchnorm. + device (torch.Device or str): Where to place the model. + """ + def __init__(self, layer, channel, use_batchnorm=True, device='cuda'): + self.model = VGG19Core(layer, use_batchnorm, device) + self.channel = channel + + def __call__(self, x): + resp = self.model(x)[:, self.channel, :, :].mean() + return resp diff --git a/featurevis/.ipynb_checkpoints/ops-checkpoint.py b/featurevis/.ipynb_checkpoints/ops-checkpoint.py new file mode 100644 index 0000000..713d1e0 --- /dev/null +++ b/featurevis/.ipynb_checkpoints/ops-checkpoint.py @@ -0,0 +1,562 @@ +import warnings + +import torch +import torch.nn.functional as F +from torch import nn +from scipy import signal + +from featurevis.utils import varargin + + +################################## REGULARIZERS ########################################## +class DoNothing(nn.Module): + def forward(self, x): + return x + +class Feature_Vector_Ensemble(): + def __init__(self, models, readout_key, eye_pos=None, behavior=None, neuron_idx=slice(None), average_batch=True, device='cuda'): + import copy + + self.models = [copy.deepcopy(m) for m in models] + self.readout_key = readout_key + self.eye_pos = None if eye_pos is None else eye_pos.to(device) + self.behavior = None if behavior is None else behavior.to(device) + self.neuron_idx = neuron_idx + self.average_batch = average_batch + self.device = device + + def __call__(self, x, iteration=None): + vecs = [] + + for m in self.models: + m.to(self.device) + m.eval() + + def feature_vector_forward(x, self=m.readout[self.readout_key], shift=None): + if self.positive: + positive(self.features) + self.grid.data = torch.clamp(self.grid.data, -1, 1) + N, c, w, h = x.size() + m = self.gauss_pyramid.scale_n + 1 + feat = self.features.view(1, m * c, self.outdims) + + if shift is None: + grid = self.grid.expand(N, self.outdims, 1, 2) + else: + grid = self.grid.expand(N, self.outdims, 1, 2) + shift[:, None, None, :] + pools = [F.grid_sample(xx, grid) for xx in self.gauss_pyramid(x)] + y = torch.cat(pools, dim=1).squeeze(-1) + return y + + m.readout[self.readout_key].forward = feature_vector_forward # monkey patching the original readout forward + m.modulator = None # avoids using the modulator on the output of readout (this is part of the forward of the model in base.py) + m.nonlinearity = DoNothing() # to avoid applying the nonlinearity in the forward of the model + + vecs.append(m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,:, self.neuron_idx]) + + vecs = torch.cat(vecs, dim=1) # batch_size x (num_models x feature_vec_length) + #vecs = vecs.mean(0).mean(0) if self.average_batch else vecs.mean(0) # copied from original Emsemble + + return vecs + + +class TotalVariation(): + """ Total variation regularization. + + Arguments: + weight (float): Weight of the regularization. + isotropic (bool): Whether to use the isotropic or anisotropic definition of Total + Variation. Default is anisotropic (l1-norm of the gradient). + """ + def __init__(self, weight=1, isotropic=False): + self.weight = weight + self.isotropic = isotropic + + @varargin + def __call__(self, x): + # Using the definitions from Wikipedia. + diffs_y = torch.abs(x[:, :, 1:] - x[:, :, -1:]) + diffs_x = torch.abs(x[:, :, :, 1:] - x[:, :, :, :-1]) + if self.isotropic: + tv = torch.sqrt(diffs_y[:, :, :, :-1] ** 2 + + diffs_x[:, :, :-1, :] ** 2).reshape(len(x), -1).sum(-1) # per image + else: + tv = diffs_y.reshape(len(x), -1).sum(-1) + diffs_x.reshape(len(x), -1).sum(-1) # per image + loss = self.weight * torch.mean(tv) + + return loss + + +class LpNorm(): + """Computes the lp-norm of an input. + + Arguments: + weight (float): Weight of the regularization + p (int): Degree for the l-p norm. + """ + def __init__(self, weight=1, p=6): + self.weight = weight + self.p = p + + @varargin + def __call__(self, x): + lpnorm = (torch.abs(x) ** self.p).reshape(len(x), -1).sum(-1) ** (1 / self.p) + loss = self.weight * torch.mean(lpnorm) + return loss + + +class Similarity(): + """ Compute similarity metrics across all examples in one batch. + + Arguments: + weight (float): Weight of the regularization. + metric (str): What metric to use when computing pairwise similarities. One of: + correlation: Masked correlation. + cosine: Cosine similarity of the masked input. + neg_euclidean: Negative of euclidean distance between the masked input. + combine_op (function): Function used to agglomerate pairwise similarities. + mask (torch.tensor or None): Mask to use when calculating similarities. Expected + to be in [0, 1] range and be broadcastable with input. + """ + def __init__(self, weight=1, metric='correlation', combine_op=torch.max, mask=None): + self.weight = weight + self.metric = metric + self.combine_op = combine_op + self.mask = mask + + @varargin + def __call__(self, x): + if len(x) < 2: + warnings.warn('Only one image in the batch. Similarity regularization will' + 'return 0') + return 0 + + # Mask x + masked_x = x if self.mask is None else x * self.mask + flat_x = masked_x.view(len(x), -1) + + # Compute similarity matrix + if self.metric == 'correlation': + if self.mask is None: + residuals = flat_x - flat_x.mean(-1, keepdim=True) + numer = torch.mm(residuals, residuals.t()) + ssr = (residuals ** 2).sum(-1) + else: + mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.view(-1))) + mean = flat_x.sum(-1) / mask_sum + residuals = x - mean.view(len(x), *[1, ] * (x.dim() - 1)) # N x 1 x 1 x 1 + numer = (residuals[None, :] * residuals[:, None] * self.mask).view( + len(x), len(x), -1).sum(-1) + ssr = ((residuals ** 2) * self.mask).view(len(x), -1).sum(-1) + sim_matrix = numer / (torch.sqrt(torch.ger(ssr, ssr)) + 1e-9) + elif self.metric == 'cosine': + norms = torch.norm(flat_x, dim=-1) + sim_matrix = torch.mm(flat_x, flat_x.t()) / (torch.ger(norms, norms) + 1e-9) + elif self.metric == 'neg_euclidean': + sim_matrix = -torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) + else: + raise ValueError('Invalid metric name:{}'.format(self.metric)) + + # Compute overall similarity + triu_idx = torch.triu(torch.ones(len(x), len(x)), diagonal=1) == 1 + similarity = self.combine_op(sim_matrix[triu_idx]) + + loss = self.weight * similarity + + return loss + + +# class PixelCNN(): +# def __init__(self, weight=1): +# self.weight = weight +# +# self.pixel_cnn = ... # load the model +# +# @varargin +# def __call__(self, x): +# # Modify x to make it a valid input to pixel cnn (add channels) +# prior = self.pixel_cnn(x) +# loss = self.weight * prior + + +################################ TRANSFORMS ############################################## +class Jitter(): + """ Jitter the image at random by some certain amount. + + Arguments: + max_jitter(tuple of ints): Maximum amount of jitter in y, x. + """ + def __init__(self, max_jitter): + self.max_jitter = max_jitter if isinstance(max_jitter, tuple) else (max_jitter, + max_jitter) + + @varargin + def __call__(self, x): + # Sample how much to jitter + jitter_y = torch.randint(-self.max_jitter[0], self.max_jitter[0] + 1, (1,), + dtype=torch.int32).item() + jitter_x = torch.randint(-self.max_jitter[1], self.max_jitter[1] + 1, (1,), + dtype=torch.int32).item() + + # Pad and crop the rest + pad_y = (jitter_y, 0) if jitter_y >= 0 else (0, -jitter_y) + pad_x = (jitter_x, 0) if jitter_x >= 0 else (0, -jitter_x) + padded_x = F.pad(x, pad=(*pad_x, *pad_y), mode='reflect') + + # Crop + h, w = x.shape[-2:] + jittered_x = padded_x[..., slice(0, h) if jitter_y > 0 else slice(-jitter_y, None), + slice(0,w) if jitter_x > 0 else slice(-jitter_x, None)] + + return jittered_x + + +class RandomCrop(): + """ Take a random crop of the input image. + + Arguments: + height (int): Height of the crop. + width (int): Width of the crop + """ + def __init__(self, height, width): + self.height = height + self.width = width + + @varargin + def __call__(self, x): + crop_y = torch.randint(0, max(0, x.shape[-2] - self.height) + 1, (1,), + dtype=torch.int32).item() + crop_x = torch.randint(0, max(0, x.shape[-1] - self.width) + 1, (1,), + dtype=torch.int32).item() + cropped_x = x[..., crop_y: crop_y + self.height, crop_x: crop_x + self.width] + + return cropped_x + + +class BatchedCrops(): + """ Create a batch of crops of the original image. + + Arguments: + height (int): Height of the crop + width (int): Width of the crop + step_size (int or tuple): Number of pixels in y, x to step for each crop. + sigma (float or tuple): Sigma in y, x for the gaussian mask applied to each batch. + None to avoid masking + + Note: + Increasing the stride of every convolution to stride * step_size produces the same + effect in a much more memory efficient way but it will be architecture dependent + and may not play nice with the rest of transforms. + """ + def __init__(self, height, width, step_size, sigma=None): + self.height = height + self.width = width + self.step_size = step_size if isinstance(step_size, tuple) else (step_size,) * 2 + self.sigma = sigma if sigma is None or isinstance(sigma, tuple) else (sigma,) * 2 + + # If needed, create gaussian mask + if sigma is not None: + y_gaussian = signal.gaussian(height, std=self.sigma[0]) + x_gaussian = signal.gaussian(width, std=self.sigma[1]) + self.mask = y_gaussian[:, None] * x_gaussian + + @varargin + def __call__(self, x): + if len(x) > 1: + raise ValueError('x can only have one example.') + if x.shape[-2] < self.height or x.shape[-1] < self.width: + raise ValueError('x should be larger than the expected crop') + + # Take crops + crops = [] + for i in range(0, x.shape[-2] - self.height + 1, self.step_size[0]): + for j in range(0, x.shape[-1] - self.width + 1, self.step_size[1]): + crops.append(x[..., i: i + self.height, j: j + self.width]) + crops = torch.cat(crops, dim=0) + + # Multiply by a gaussian mask if needed + if self.sigma is not None: + mask = torch.as_tensor(self.mask, device=crops.device, dtype=crops.dtype) + crops = crops * mask + + return crops + + +class ChangeRange(): + """ This changes the range of x as follows: + new_x = sigmoid(x) * (desired_max - desired_min) + desired_min + + Arguments: + x_min (float or tensor): Minimum desired value for the output. If a tensor it + needs to be broadcastable with x. + x_max (float or tensor): Minimum desired value for the output. If a tensor it + needs to be broadcastable with x. + """ + def __init__(self, x_min, x_max): + self.x_min = x_min + self.x_max = x_max + + @varargin + def __call__(self, x): + new_x = torch.sigmoid(x) * (self.x_max - self.x_min) + self.x_min + return new_x + + +class Resize(): + """ Resize images. + + Arguments: + scale_factor (float): Factor to rescale the images: + new_h, new_w = round(scale_factor * (old_h, old_w)). + resize_method (str): 'nearest' or 'bilinear' interpolation. + + Note: + This changes the dimensions of the image. + """ + def __init__(self, scale_factor, resize_method='bilinear'): + self.scale_factor = scale_factor + self.resample_method = resize_method + + @varargin + def __call__(self, x): + new_height = int(round(x.shape[-2] * self.scale_factor)) + new_width = int(round(x.shape[-1] * self.scale_factor)) + return F.upsample(x, (new_height, new_width), mode=self.resize_method) + + +class GrayscaleToRGB(): + """ Transforms a single channel image into three channels (by copying the channel).""" + @varargin + def __call__(self, x): + if x.dim() != 4 or x.shape[1] != 1: + raise ValueError('Image is not grayscale!') + + return x.expand(-1, 3, -1, -1) + + +class Identity(): + """ Transform that returns the input as is.""" + @varargin + def __call__(self, x): + return x + + +############################## GRADIENT OPERATIONS ####################################### +class ChangeNorm(): + """ Change the norm of the input. + + Arguments: + norm (float or tensor): Desired norm. If tensor, it should be the same length as + x. + """ + def __init__(self, norm): + self.norm = norm + + @varargin + def __call__(self, x): + x_norm = torch.norm(x.view(len(x), -1), dim=-1) + renorm = x * (self.norm / x_norm).view(len(x), *[1,] * (x.dim() - 1)) + return renorm + + +class ClipRange(): + """Clip the value of x to some specified range. + + Arguments: + x_min (float): Lower valid value. + x_max (float): Higher valid value. + """ + def __init__(self, x_min, x_max): + self.x_min = x_min + self.x_max = x_max + + @varargin + def __call__(self, x): + return torch.clamp(x, self.x_min, self.x_max) + + +class FourierSmoothing(): + """ Smooth the input in the frequency domain. + + Image is transformed to fourier domain, power densities at i, j are multiplied by + (1 - ||f||)**freq_exp where ||f|| = sqrt(f_i**2 + f_j**2) and the image is brought + back to the spatial domain: + new_x = ifft((1 - freqs) ** freq_exp * fft(x)) + + Arguments: + freq_exp (float): Exponent for the frequency mask. Higher numbers produce more + smoothing. + + Note: + Consider just using Gaussian blurring. Faster and easier to explain. + """ + def __init__(self, freq_exp): + self.freq_exp = freq_exp + + @varargin + def __call__(self, x): + # Create mask of frequencies (following np.fft.rfftfreq and np.fft.fftfreq docs) + h, w = x.shape[-2:] + freq_y = torch.cat([torch.arange((h - 1) // 2 + 1, dtype=torch.float32), + -torch.arange(h // 2, 0, -1, dtype=torch.float32)]) / h # fftfreq + freq_x = torch.arange(w // 2 + 1, dtype=torch.float32) / w # rfftfreq + yx_freq = torch.sqrt(freq_y[:, None] ** 2 + freq_x ** 2) + + # Create smoothing mask + norm_freq = yx_freq * torch.sqrt(torch.tensor(2.0)) # 0-1 + mask = (1 - norm_freq) ** self.freq_exp + + # Smooth + freq = torch.rfft(x, signal_ndim=2) # same output as np.fft.rfft2 + mask = torch.as_tensor(mask, device=freq.device, dtype=freq.dtype).unsqueeze(-1) + smooth = torch.irfft(freq * mask, signal_ndim=2, signal_sizes=x.shape[-2:]) + return smooth + + +class DivideByMeanOfAbsolute(): + """ Divides x by the mean of absolute x. """ + @varargin + def __call__(self, x): + return x / torch.abs(x).view(len(x), -1).mean(-1) + + +class MultiplyBy(): + """Multiply x by some constant. + + Arguments: + const: Number x will be multiplied by + decay_factor: Compute const every iteration as `const + decay_factor * (iteration + - 1)`. Ignored if None. + """ + def __init__(self, const, decay_factor=None): + self.const = const + self.decay_factor = decay_factor + + @varargin + def __call__(self, x, iteration=None): + if self.decay_factor is None: + const = self.const + else: + const = self.const + self.decay_factor * (iteration - 1) + + return const * x + + +########################### POST UPDATE OPERATIONS ####################################### +class GaussianBlur(): + """ Blur an image with a Gaussian window. + + Arguments: + sigma (float or tuple): Standard deviation in y, x used for the gaussian blurring. + decay_factor (float): Compute sigma every iteration as `sigma + decay_factor * + (iteration - 1)`. Ignored if None. + truncate (float): Gaussian window is truncated after this number of standard + deviations to each side. Size of kernel = 8 * sigma + 1 + pad_mode (string): Mode for the padding used for the blurring. Valid values are: + 'constant', 'reflect' and 'replicate' + """ + def __init__(self, sigma, decay_factor=None, truncate=4, pad_mode='reflect'): + self.sigma = sigma if isinstance(sigma, tuple) else (sigma,) * 2 + self.decay_factor = decay_factor + self.truncate = truncate + self.pad_mode = pad_mode + + @varargin + def __call__(self, x, iteration=None): + num_channels = x.shape[1] + + # Update sigma if needed + if self.decay_factor is None: + sigma = self.sigma + else: + sigma = tuple(s + self.decay_factor * (iteration - 1) for s in self.sigma) + + # Define 1-d kernels to use for blurring + y_halfsize = max(int(round(sigma[0] * self.truncate)), 1) + y_gaussian = signal.gaussian(2 * y_halfsize + 1, std=sigma[0]) + x_halfsize = max(int(round(sigma[1] * self.truncate)), 1) + x_gaussian = signal.gaussian(2 * x_halfsize + 1, std=sigma[1]) + y_gaussian = torch.as_tensor(y_gaussian, device=x.device, dtype=x.dtype) + x_gaussian = torch.as_tensor(x_gaussian, device=x.device, dtype=x.dtype) + + # Blur + padded_x = F.pad(x, pad=(x_halfsize, x_halfsize, y_halfsize, y_halfsize), + mode=self.pad_mode) + blurred_x = F.conv2d(padded_x, y_gaussian.repeat(num_channels, 1, 1)[..., None], + groups=num_channels) + blurred_x = F.conv2d(blurred_x, x_gaussian.repeat(num_channels, 1, 1, 1), + groups=num_channels) + final_x = blurred_x / (y_gaussian.sum() * x_gaussian.sum()) # normalize + + return final_x + + +class ChangeStd(): + """ Change the standard deviation of input. + + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. + """ + def __init__(self, std): + self.std = std + + @varargin + def __call__(self, x): + x_std = torch.std(x.view(len(x), -1), dim=-1) + fixed_std = x * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + return fixed_std + +class ChangeStats(): + """ Change the standard deviation of input. + + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. + """ + def __init__(self, std, mean): + self.std = std + self.mean = mean + + @varargin + def __call__(self, x): + x_std = torch.std(x.view(len(x), -1), dim=-1) + x_mean = torch.mean(x.view(len(x), -1), dim=-1) + fixed_im = (x - x_mean) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + return fixed_im + +class ChangeMaskStd(): + """ Change the standard deviation of input. + + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. + """ + def __init__(self, std, mask): + self.std = std + self.mask = mask + + @varargin + def __call__(self, x): + mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() + mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) + fixed_std = x * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + return fixed_std + +class ChangeMaskStats(): + """ Change the standard deviation of input. + + Arguments: + std (float or tensor): Desired std. If tensor, it should be the same length as x. + """ + def __init__(self, std, mean, mask, fix_bg=False): + self.std = std + self.mask = mask + self.mean = mean + self.fix_bg = fix_bg + + @varargin + def __call__(self, x): + mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() + mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) + fixed_im = (x - mask_mean) * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + if self.fix_bg: + fixed_im = fixed_im * self.mask + self.mean * (1 - self.mask) + return fixed_im diff --git a/featurevis/.ipynb_checkpoints/utils-checkpoint.py b/featurevis/.ipynb_checkpoints/utils-checkpoint.py new file mode 100644 index 0000000..262f679 --- /dev/null +++ b/featurevis/.ipynb_checkpoints/utils-checkpoint.py @@ -0,0 +1,88 @@ +import torch + + +def varargin(f): + """ Decorator to make a function able to ignore named parameters not declared in its + definition. + + Arguments: + f (function): Original function. + + Usage: + @varargin + def my_f(x): + # ... + is equivalent to + def my_f(x, **kwargs): + #... + Using the decorator is recommended because it makes it explicit that my_f won't + use arguments received in the kwargs dictionary. + """ + import inspect + import functools + + # Find the name of parameters expected by f + f_params = inspect.signature(f).parameters.values() + param_names = [p.name for p in f_params] # name of parameters expected by f + receives_kwargs = any([p.kind == inspect.Parameter.VAR_KEYWORD for p in + f_params]) # f receives a dictionary of **kwargs + + @functools.wraps(f) + def wrapper(*args, **kwargs): + if not receives_kwargs: + # Ignore named parameters not expected by f + kwargs = {k: kwargs[k] for k in kwargs.keys() if k in param_names} + return f(*args, **kwargs) + + return wrapper + + +class Compose(): + """ Chain a set of operations into a single function. + + Each function must receive one positional argument and any number of keyword + arguments. Each function is called with the output of the previous one (as its + positional argument) and all keyword arguments of the original call. + + Arguments: + operations (list): List of functions. + """ + + def __init__(self, operations): + self.operations = operations + + def __call__(self, x, **kwargs): + if len(self.operations) == 0: + out = None + else: + out = self.operations[0](x, **kwargs) + for op in self.operations[1:]: + out = op(out, **kwargs) + + return out + + def __getitem__(self, item): + return self.operations[item] + + +class Combine(): + """ Applies different operations to an input and combines its output. + + Arguments: + operations (list): List of operations + combine_op (function): Function used to combine the results of all the operations. + """ + + def __init__(self, operations, combine_op=torch.sum): + self.operations = operations + self.combine_op = combine_op + + def __call__(self, *args, **kwargs): + if len(self.operations) == 0: + return + else: + results = [op(*args, **kwargs) for op in self.operations] + return self.combine_op(torch.stack(results, dim=0)) + + def __getitem__(self, item): + return self.operations[item] \ No newline at end of file diff --git a/featurevis/__pycache__/__init__.cpython-36.pyc b/featurevis/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7b804d205002bc2f47915c53e11f78e930a940c GIT binary patch literal 153 zcmXr!<>k6PJ3U^Ofq~&M5W@izkmUfx#XLYFg&~D8harR^g(;Xplldi3gh7+>7NeG* zCSw$TT54iRX;ErfX0cv!eo^X5h9YL5Jec^Ure9o?tdCHE%#4rE%*!l^kJl@xyv1RY Ro1apelWNBZ)LINO9{`PXC7}QS literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/__init__.cpython-38.pyc b/featurevis/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81e9f46f6c85f95202226231f075f7e21196fd87 GIT binary patch literal 184 zcmWIL<>g`kf~8`Q610KzV-N=!FabFZKwK;UBvKes7;_kM8KW2(8B&;n88n$+0!0}# z8E^5Y7bT`-rskEzCl)6IDL+l7DE_q6#FEmY)UwQCz2y9&)FO~sD;bKIffShdrKVq8 ml&p_XhRlqQ&&wB_;6=SEG?7IkB^rWeL{GR$#AX$+3a~6rzXKb>gk&9n7-<%e(nZFh82)Ba6c_%v|;068S38Wq z^+O%M4Obr-hlU>acqp&56c)+=Z*6mxK;QHZ-TDE_1Cq|>OIJ*-RkI3!5@dt2sdjl+g3Oc z_P3ni=Co&{*Y~2_>tB9p@cy^y^LJl#ew@>^dmICMbsCP(CN9$bOSpm$4Na5!Pz&{; zagr15Fvs1eeqn=HCg1wi6MR~EDcSm5A?pybF$><()q#lyj5O0DU0vZ z-LR%)FwkR)A4uJ+NJHv!m79NR%vw^Dt#f_0CL6=LTpKpdwR0U3m&H%znk@73Htu<4 zTWf141@Y5YH3|Ekl<(?dN9JTJ;nJ2X7~M`sdwE`+wdGn>lkH7yxT5BdWim1Hg|NwM z%2s)j2|cfpoL)`l={x2r^==imRl1z(yndn$Tj$VE{6V-jY-62C%KC6!@h&7X{XIr( zoNIr!gJ*?QM+yJpr9U>F)85c{=^NT>+V5y`Rn|5%UOh4H8lo8M4I7YdB+oy~wpWbx zfgbvB6DtbK%+|v#zB1g#=r!4v>*skTMQrPL(OZpqig#rb_Q*VesBXXe2Kfp}cLeFw zYGCfKU_BbidSDIjyC$*a4e?%L`IP>G_2*hb+9srJ@YQXsY9_0Rd4DvQ&NF0lwjnoU zL$365*e@;X!?LEauUS)PF~9ZoH+hh0Zb68IwaLVv6q zw*yCDKcw+dSz*C$&hkF;{4lXmc=kd1M=o1k>B!>h%*jZ7TUisYCqdjh{F_27vmlxD8*eyI|=B+SLWHIR%EE&nv;?MtZ#>;e z6s4ix#C!-HNsyo&q2`;<1fPJ(yq>Tv>|nUenGHkq{1LoDCF3)JS+Y$r-vep~rFOV} zJ&kXOD+sDePozA=JjY`k{8To^27%@siZmnZ1k>T&gh(j}y7S~2gtVE?d~rgH34tt* zTn0Ksx=S>`49ct%dew>j_zptQXo7u62OMlgb(~Rg{Mlz158oQwB9GUb$Z$oJr@()w zb8|Yz`3|d~!bY4mASW1HLxQ+Q0rMJBUc0AbB)w*pGxJ9^Sbt!LT^CuvjT$4{=~{GH zRJ&TxfIHh?PLGw`;f$gOOpcvCJsAA?hoAa!^G%EC5xO>zP_U#D*WzeOR(-n9@)RZwri7Z;c$#`H#d3qQXNb+t}MD~X_ zMR^!(6q!d>kGzEoyn1R;&N>RvxNc;k)5Eq1qCDM2c}lWT$@A4rQ4V@V1(gD#BAvaF zls6;2AL-MmoNZ&0Z}BW1RY(##&UgD!bzu)jmH9$P=fhRFUb4HpaaYt> zPQ_7Wo+B{9Jex&j#fgp@kXOb2sGJ4Y$fRMsI}IY;iRzjB)D;yJd1R*4QDNFu+Jj?v z`d6CxO<3-~9)Btjy{G!|EB>hyEZ$2J%Z=#|_S`Wr^xXzNC<0=lM=&ovZ1(>L(kL~ljEiary+6|Y=d-$3tGgGN^L zroN@Oayy3jJZ2j_t3Ln!#a@dh$LBFz8O-n#xPmk;ff)@Y28UuZ{ftT2dEYZv4U1R#!VHNPhN(Mg|Z@xd< z1bvNbfFJ&W?uK>sif*FE6#pm^3p9fV7)N7Eh4f(EMt}B6EZPWY!U}^whb^yQ_;{9-Uc!k&1inNB0 zD7#jbT@CS17;!ZLV5;dV1MC2xmjEzY0>Es_Re&WX?35EMUU_%{tuVn8|0#C?z^GNl zY8t~w0l<(qJQ_0I7(OO9<+j|Fk0t<2lV%s+LvJ(YiTe$BMdr68>+SC;0EVO^07m&E z=01W)HWH5{K;?d38T(%jD;@h^N`Juz0l*|$LfREbyT)4?07J5xnD<}j(gA?km@&!Z zI>Ac)JRq30TMwA1MG?_LC74f;sD+6^9bHh&Q#m*)A~|t?1b|e8$NoJ^UH>1+SJX(N ztm!;12zwP24aEvIO=?!Dp=c@AsJW15t0T*s;N>Q;Z7$kGuujbeHH6@bEo!#WM0t8; zR*9K=Q6V_C#>mgT3Ad18Z;KF#bux-_+z+Gtsbims9U8ey%@t}Mq2?+zk5a>^q2MhZ zN7H#s{0hDf3w=89h+n1qQgZw`ti(o3!%|10xQgcAfQ`CH#ny1l3)%hta5YJHev($WsnqMb^97**XbXSHH1mOAJVOgDA z$SQ}8Gs`_80pmyFvo!K^)KH3zn;SH|2FN7zC!$LO?xH7n2aT5hSy>br(Ac6J8E4X5 z4R>iCt>_KpPUJ_Ug|?!b$d)x^(S5zB^5zDzDm`x-_sO*ROET?OA(8U>dsWgYF2+MhMKI$3&>5ia-vjYMqynk~bjb22#@|(DkC+%%siJ zc%-=(fYNUyv|Fee6y;V*gXF6trEenTZY|*cG&7; z+`o<_LbyLt3=sMh_y4ZK{gH|wc{{=VscJ$p{R>8o&?|gtcF_7 zq9j#`-Yt#1_x1-%wFkBCnEfZJ_7JZ;yyXE_KbNh3N`Juvkopo!!(t6stiDitc#u6o z`-jrwd$4|T=tO#4!7*@0HetVpN{=n;_YgK8q(Z^)`9&#EkSs4gtWP|wPuLIZ69m~l ztWOXGm*NmfQT5XLghJ023KS`lK0oBKm;~tgiy=EB4FBS@|I;dlf)yPB91%667}Q*t zPvLi{c37-ui_iiLsid1j%P}U{zoFpC7$MAxrKmH+)vJtr0Xj-?-d8_qA%tS@!#c>r zI>^V=LC8($L!0uFGEcf!RXJg~9F=*iy7^@&rNox{rLCkW;6%MsemqojE3O0lJXlQv z)BJ)}N#+=hy6fzI3{W!%UM_)bE}}Gq&8QN{CjwleoNId!gix0lZZVVEQ(rtFoN`!I z6^l5P#;{6;s3;KSFpn%3L8uP;|djf z#uY#?&0GtdTO}%kG?xn(xfY(aP!tj0fFzx2jD#tGj&QiBfEp00D~2~dT%Q+U4(#-w zEQ5Gqsq!HRl!;9I<54iSa8MwI3*eH1nH0igK8OEhnz;7!R4xn%dNWZ;iPbI=9`yTK Mk*Y1tNfGV;0*00?LjV8( literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/core.cpython-38.pyc b/featurevis/__pycache__/core.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a45b3e5b431607af60ad6e76075d57778d86557e GIT binary patch literal 4408 zcmbVQ&2JmW6`xsth@_|wOR{Y15Da>VMO$X#6a@-5NgKp=>Hu|GJ6|9WFe~nmT4}k< z%nT)3US8_ejr9SN#odl|25CHEPdckKJ$Zq!bN|-^az~UFn*kk{|l|&Zr}? z8ih&W;XAi`pZ}R&U;fnpy1>|T4~m^SsZU?P%?Rh)c@iZT5_R5|7t`Y1vyks;a-y)ue9scd$}XU&K7D z#ZJuQb+7U}XM7=M@r5URyb-TVR^pAx>KQxZKwGf--^7LZ!c=lIUWLSFCJ`3B>UcBW zSZ49&B{o^Jd!+kTo^d72x>vKYDAK-Id6lq)^|(mism++Tmkpm>pp`T3Eg!MT#uXVDsc8L(--sjNRK4ZV%0m@S5M~tj{OTTqqXCJX2v0t$V>|++M$IIKy zs~$Pf`giIZ{3Oo^&p+bLu$=k>KltPlG6wI*TjsL2GPwfnjd(NOIx9Y*c+_k>o?^9@ z+Eh>DHN+#&G-3Vh=@i>OG;F+|IqGFZe03UeWa)oL9Xe(j_e}m=>}Ng#>ngCWcxzXX zw;X8&HvT%p7CQ0T_+or9UWr$`1$4x^`&E@O@e6n4_x)2Ty1S!>IQCu9Q?BRB&v2Y8sdgfvNsG|<)6CLM2okr_6GycHBcS3ADinp z$Knk!h_q=B?eZ?Ij>UDMjU2Q!fw`8WXag7BZW63UBL(x8>J9tArf*s6gs&@hyTcF& zqp)#HJdkd1NEiffRl?7#cE?S!m`K^6)HRy1j@a7qT%E?qCr3KnsH-;6iYv&@%M= zuqS+zn`c{11&ve|3y2{#me-|b1!lc7{Dyx0?mzA;k4%AU|2H?SAd zbY@@|bN79S&q=~;KifGZCUt`am;>b#023L6?ikf!9o-ZAet=qlwCMT)E;NkH1Ip^J zy_nMbQFvo9l})6%BTo&e1Q8<1r1lm1 zA>&6Ig}J!-i+vPEW*Q@N;A>rjUWO zgJhNvuv{Be+@B%+kh(0Z{1=em_n=-tdCmijng0{@qSed;ai>2pXuV)J2^oDfgp~;4w>5ASf>ulOFe7*x53bKK$*LtjjON~YU5^O>L{tckNrR$Q<9*L zu=~w+LQNoKVMj?99gLDWkqAU5>Z2;`Fg{V(C2xvZ57-XM;&AO+#&6&ikgD|)BM+SC zhr)wBJB`sG@Vr4x(|3=s9iBc<?g`4Nq;TnNA{gM9Bmo*TXD>9GLC}9$*I>)*(I2 zq;-4>3hEEhhjhR}E863Xi1nvQuqz%YG?57w;n3dg%p z;XAn6aVmu(r@t+y#%qPkSYO4v&exq{Vbw|szKuJT0`BvduvWouvf?oOeOoSW@h#kY z$$=(ptnm1$1Id^8f$< literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/exceptions.cpython-36.pyc b/featurevis/__pycache__/exceptions.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2002b86441f35ed3d2ac5f8142ad0b4d49751a8a GIT binary patch literal 381 zcmYjN!AiqG5S>kejm3hXAFxMrXnXJ~QV{K}7r{e7h9x_#3u#h!6VaXo{TV;UYp(u< zCufs3b>Iz;H;>26T#iP=@ptj~4gf!lz9MEbhCAmr2Mt<$G6+7xROsLyk}%^*UxL|; z;ZC^`um{pWi!|)K&DkBPsdo63~Mb}nyJl|7ABo=e)Ra#>nQ)|S@E6%}Mv zMOy0GnqnoFU5b1$u2#9(DxWi1BvBJ17HUn1%@A>2>N@xQ1o4@TyU74iml@(0*dt!E zZNC>&XS3-pm~;QreknKEyjg#vhx5;gMI>5fkp#_ge^VYpnxsGH>Sbn91#6&}S6GkMiz?-p@exBOx*&xKm0~rkUn%1Z1yq&UJLdvRKjN zUvOd*f;*;!jC3rIG|%Hs?@z8#){VuvaaT_Y*R`q2%~V{dHEN+7Ys#fqbS~o2xJDLcBZJRqmL)y~DCG(Pd>>#{>81$v5x@fpx04=#t`xvK zvj?IP2k33zr8h)#)vLUMulk)KMM<$2$VG2TVUC9LbLPzX`Oe|B zjg9u#Uw`t)&YO(=hb=ud^lzc*4?qMHR>b=BZ%5Y1?%Ni-$3#sy&zW#$cE5(Vx@h37 zfj0+lP0_+z3vYE{ea76iZ@`D`xK`de@RhIj!Z@Ij`O`$_7MlJAh-7_Bu)Zyx7FTcB;!=SZ(eDrnCIOn)T#SEzs;#b8^_Z$QNe!2fELrE zq%V?5>OGND-qoqXrq5Cp#(O*zU>y#o)F+vA;K%&gegdgtIZ+UgKMSLX?@A5^<4KxI z!FQ*XD8!xi8Ih_{IhEcx(Y$NK={=CKPUz6v{PU~)kpKKKPt6c`r~76Yd zH=c~csC&50r*5xeONTw!4>i~O;ULv!;Yar$(jFf&1~P)y_+2^hCsE3~J4q~Ej^!0| zKgFUrl?q!{xavSj8S`$~lf7*ord)*DhtY~N%yCjJNwO>V{ev)3C*APct2eB+jNxh{ z2_f`~2wih!PlSOl{w|PpI9Kj&&;-0u*n!v>AM8)J&xce$+QZkH3HkuU7 z7b-1`?1kbGmyh8@it8v0U~Of*3P#&8e$dtK;+VzZ#j)_+O8?cRrk>H;Ha{#nygP^z zSOA<0FD-lkC)`I+JX2v>gatxHL6YuRs!L?jx%aviXYvEXyYe5n>wzClV6Oq#FNEO_ zi&0-m9z@}I4DW@qKEHHzn_qp5SdemsYvHeP+#5{dfXv`Wy*(8QPy3^BB$u>4(WP^g z;+7#+$hFX~U&On&>!*mz?rxG`eT+N*cEBH~iQFcO85DpHA!NB;RG5JKha(_{=3z_@ zzannQwTMjebf3qQkvEUrQo%ib9~;%PP~*67uPvD$uJC=8$>K&r9*}>Op?$Y_BeyZI z@(2gPj0uOSq3Ss@%)x9YN#z2^9>FNdc)GNVcKQcND0ou(#2lFRlrKVpLEiOa!O18* z98|uQsOkcx-;p|ir|uk45)}g9{b&x3{13^56WaMfAc4NgL>1DM2vmZszlf#L)B|c6 zFz*$!g;sVR;+ zD_bAd&>XZnS_7>q?62y_ovbr#;cackW|oD$Lu=U1I@Eu9<`K(ma9hu6f<0-eeZk^Z zRvUJ*HE?9!M&_9DKbdi-8sE(7n0+H_fNo_?&{J6p^mMic`sQIwr$9OZ>COz_nz6s! zGAD0=+nV|}X15@bli6>x;aO3?K~kNfxxX^?lKM-tjT`I{^7E(cckK5J<3=`cTOXdA zG2G#wG>a_R+)+>xbL-G!qGaAIgDGDtAuCaNCr;uhjDZbdI?bCUB=^2C8||JV-MjcV z@8^lpc$zl~Gv!V?1)3oLGSwhLiCwjbtbycjkh6L^^-~G_4br^5)NlAejacOCOGz}h z(=C zfg*2Gr-+~?V(JW$w}_l2a*oJ(B5xB}2g$8bzcKPi3;$q>W8~$#m$eEm52TMofvDBX z-O`<*vXq8j@`!GX{%#hMDOU-yxi%{ z`2;rcz~i9R%BJt4^9B3D8lavM_Vd=4Y{>4y%a85U8rm5ut798uHT7O*4;@jPSp|iU zm+!~5tOnn4b^0u40wjq#ZFT6wk}so@XME`W?@EI`N}&rs;Vi2{2qY<%0Sl zm@AhEUnQgyMP{eKGsm|sIF^IsH!qs;0OQp|3vZ$6AA_t^+-t%S_2*XKk*MiK^ErG4 zHFgU|Yv*eZ@7=q4{SKhR--R>q+kA|=MEQUV!7+E~>UHEmQ@&Q!EQ%eeMpA?bdR_(v zaxpe)WEoR}nT*oiLBVSo$hR+RE%AyH;sxwPwR zDXPR&tV#F5xhl2CX*ddxq*$a~)Eh++5hrT2Tu30}Qg)}zDUxS#m3NUpH5JsR#5RQj z?OZVYj(L0>`N;NFA}{toP!!Ao5qik9)W3tK4?rlUBQ~;*9iY9fE@lpb4qr)MS#cZv zTG2nQXIAQD^Is%vqJECOKu{tdHR7$bDH`)tGyBiTZNmn#A`rpkr3Ph3 zYc-EpCVn2cR=>S)1d}0-E)?3Pau|7D`7yr5x+DJ()q>mZuNx=^HbQZRN56Hjw|Dir zw;Shm)5~j-jPq9MFgmXr_o z5kv9xDVp8_VOGc9LeOqnXU+f7>B`|>g;^WxsTpHXxIWn^kEqv>$YZzOB366o{ zd~-BK@nbZDT+CiQtN@7}*DhSZZK|Kr?w=8%WT7q*A?XzfaWW)a#_Y#vnw+QA0w8o0 zjlCWYh~ewupa27Wb{9}kH=6PP{#{{!9J@@*z#-n^JV{!2tp+pJ@j882vssETsEs^&a4I$uuP?kv|YGx z%{Yqj(BBmbV)H9?Ctq4Qfz!!q*Xwx{&tD!{Mh}_eJ5_$JL zlmzhR1*-2M>U!!Gbl{*SwrA`Z^~+pR3bsO?pP=W~7P(t>X^K~*ioG$0O4+(gvVA-9 z8Yf5IiFx=}V7*K1P0+0&=p033Kq@LW`df?Yus2D=NEbm&dMI>Gi9PB?f1xkwcc{5|lDOE1zElIAAu00k@Laxg^oNy| z4#V^5#ee-}MT65%1B2UW_SYbaDW0-E{fm?jMPG1spQ(oOo-ySeiGBm4rfOl- z!pOs@t$d7pjGBr+V8PPY;KSAfUirI`iOg1##WZvJX<~32&0Yi1tj`te3&r~lC6v&f z5=WfQ95mfo9Gu-L{gx7RLgjy)Sv}lLb#&}8ChzQO6K!c(Y-?$>9p!i{quAuu%1ByW z$b2A&xzefabvhEy9kVqa>a4IIxgkx}?`1blY!Q4U??~#<#?gL}n|OQ1fELqZbfofe z5kA)YvTF;2O%Do_WLq*(V4V#1sZTQ5ILhSH?Hp2NdTbz`e43=G+|&{bM&qK;N^b7Y zL?Q09&xtgf)%!Xe*_;l&BmZ<=?#W*~l7*WB?_%5S$Lgd=@{Ddl{6^zZ zl6Lpj&_3lHkcnXKfFE`zB|+Z>{3zf>fvToz$Lqzd5$2+ z!0@*Nxnah7Z59C7ZV(0adNm6NuuO&s7AupCY(3*lelX!$J0%%8lG%6|PMx;)FKFpA zY&1_3i{oBjJ7K=J!1qlib7d*LORAZ8^}TvT8gmi#5C5z)>7)07^bK z^(m8}n&3uc<#0bl06JXiO{FBQu5VOcJXTTc1MQ~I5<0*xM(}I@2BH9hDf>Hn&ITMX z*m&lb{2n{vB@1~eKt@_&|5lToITl54B+am8xCn=BGX5pLy-M#GLGu@j#xG?*V(s2=tZKBeKFvQHkEQiVt6MTptsLSp55^SFMS!4s?Xbg01c8?nG&${i<`5 z&^OM9qgy|sLrGIDCfLCTQ{?Z3VUi_981`Pi%O z)t-Q9dd3IT3HCQs#W`F<>}ohMf&lqP6uWcCm3W@X5Jz4E)mj@d5_3(%p zwGHK9vkX%CQ^CKFk<%s*wkO4iQu-9ujT z7qI>gL!*D8*q0uT=3lsD2I3N{eIgKnnCoXf@ZPGiHaNc&<|6(ozE^9Elx0>xdT5q} zXmRoCGWT9BH~~zbzTF9&9|uimr>g0aX4SMs6hC$rs=Of~r{_*Jm%+c^q~gI=9{trq zT*CCsZ1quBNE{N5@nr}@#*$*eSoOM~O{UI}mBO&PhhANLS z-E=9!yiX_okO+m#DdO}&#%`fmaz3AX7d%d3AzpRP8+sR`Ej%=N8_oUT2-@D|ipK7624Eq#9f{`DJobA-(%fB+@N2sz0_NrplN@2*_Gfh6Ecmsur) zM5oPAt0XG4oWwVh5jI-DtV_QRPP^+UR_>zx2JK-WQ9e*@qO?s6xTn#+HfL99?zPLR zl=CvBkz%i1*^I1K!4%2sHN`eK&&sS(kqnaqt>$@WY;~PQv)l|%XHujbN^g`pRQ@!Z zB_1RYOU0BcuUw|2opXlYFp-VY2z5r53g@2IB$(yDopeSxr~l#rb-+Nw2ObtL|Z zG_un=Mp8N9;7xs(5?n%P*9jruE|4|=@twIdd`)TM;Bu{TDu<91O_ZS)?+&9qR1iU@ zf6j#-pdQL|Jo^6b*4FhK;bvAfU9W1SI;;GN)7Yx%G*fjxkJ7RJ*qGdy^Ek&)>Iqsk zOf=n@)yjeyYt(hX+@%fk5OUE&vGpr7OIVHY73X>9l@P1^0(#5*;N6+q&$7z`)T~e@{t9ThSoXa?8uG$kFAdgaZHkAF$bt06O>v$vfb*Rmv ztdA*Iv@yQQ4_2M)ygjDK5ee$<(vCHdX-p}m09aJ9*1ehzyi4p@oUlU_HFJ4g+&QVJ zsKN!Dtd!Hu4~V=bAw}b#(IyghPf7TCEVj;$#WRyM)k(i6_H-|V;ZnylGzaMVF8=!G s=hbg-TqLPAF04rtwdQH@DVd%0q}s~ASyvIa2zKiz7t4*+Ypa+415!+W%K!iX literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/ops.cpython-36.pyc b/featurevis/__pycache__/ops.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be4d20f31ef5e7c081a3fa1992921d775e900a6d GIT binary patch literal 21895 zcmdsfTZ|l6dS2c7Iy227IpTe#T3Sm^)6|H%ATbE8JWEp4YO|VkBt~nrcik>_RrhqW zZ#q@O=^6KI0*w}{T`!$=e2pCh0oHcxAPB>@b$j06iL57tufq zaPocssj9wAQxe4mVx-ABbV zzS%Wu`fk=tDO(-8szi0UQ!0wa} z?b;G*3Vsna#Y3yMj8e%jqf|y|1*Ii_8Kq^EDk!b^6_hF{9Yg7uzlzc-N~BNxP&$RuNt90eXHYtW(i%!<{c|XtL+L4$&ifZox`5Itls@A> zjndO7okr;y-$ltq=?qGr^)I4y5v8*z{h0qOO3$Kn4yDiemr%Nd(s`6F`|BvJqjUkK zs(%HgD=2*ir62dNqI4Cdr%`&&-#}>trDsrj-oJ*@HI!W6e9Nf5@Bxoyt7^tpzmGH@ zwp)F#i(K)6r##ha_Zw`H{w!oRafNG00)wYjvwYLH-ZN^pZ=**iF5Mn%4WjLKztv!K z{&>ex8@F(UJpC~TH@AM@s9LcT2Hj?Cj#M5GB>C{O&xfkh-u>ulEN2PM7)Rdi|XpudAP^ays;6 z5~{?y9Fpa9h@vUwnH^z+O*Ys-GPNUSVEg7FcE-1xIp6Vf@0m5nFZy}EfLu;?zZ9Ro zqt{q}J7`1$Re!Y~2EBXTVC!z|GHV=&yqNn0D&VzY-z zhZTCOxyv7xZ*<#X)EM-JuMn{0JoCo>%a7Qdje5P^Z%6g|#*OZv;dR4TkV!kJmK3KJ z=W*0QH;k85;Q51{sD3}#i>+u77lOT@J{*K`@m{d)J!lV9T-d^Hbv;8}e=@1s?{5ET!3F9Bf6V`t2s02ZAkT+6=w5TN55-?Vg! zx|ODV7C>hj?<{}Sh$@|906M_>L+ijElN#i=vWYKYuG~U_oBx2!*z6c;HR2smV;T{N zKJrcn>tg#=E|AXQf(*xW; zkiM42?59i;b?AKC=wCfr%l7G_bgt=~HBP6vg#{6}I>3lS!LWl8X1YAaxLjyw#Rpy; zl*eT(x488I(c}Z-$PB`eO31?hIOF6*K7N=LWmg! z^?vL;Xa~Es0+1AggmFF?4ZXe}+YK*@3*kFEL9icGmlVNXurSVr+wEo)n_IEjh|S&D z+*T*>u;y?kac(#m0P#&tVStL9h(^Uzi`UEsA&B(f ziwQMI(I?whoZ^IHJdKesuV;B%)imWa@<3d8VG_fInic7-0JnXTsp?JAJ z=y%)wz*FsLFV1_zVbJ%dMiIKS&VI?8s(DSpxQlVA9f8P2?EyDGXoRwT>aVkH#)UKD zr58xrCiLDg9cvl;Q?yR4Rt(BAe-sJR9f03s4kQDL995BX<0QMFuIe+a_(>*{ z;Uy4Hca@U*P zffrS;yIooK!Q!hAzN`??*+gtU0v1I(03CrD!x5+&~nCvfY;b7WecL= z{^{An$(Vj7RT4llR=AF%(*$)w&B3TJsc%|jQe)&&DlZJo*7auq4+qwQH+5_MKKQ|r z_ca@I&En=Aw&YyZGuT0)=Z}>@ z!Xj0PZSP(vX9@EDjsmGxLAdP=gV^o{{n!q7dWy##JH5c`Pm`Zo!EZO4VSO*nj3Agj zh@I{r4Cmp3MB#7X(sGl1-Mj+6x98@i+eQ)vGISN)i%uTR_@&fxo3(9it265l=U zT88h(^o|_GbGG0nlWc^WNHn%mo9O^gI(7s>m8urtKIhxW$&>StxDKERb@FIm7(*Zi z{A;lkIt}UC1nME)3!}WvTAA)0=17p#7num%dL6l{Ghw5(e0Rt_Qv}fY1rlxoTmm}= z!PVTKEO8c0)fRi62UYcDb}Ov$qrvnIw5z2<74rh7teXK-cCpDu*O1I`NT{d*rEaGQ z(cRBOJx!>2cllFjB%my(q0pnCR|y(08d{?nJOlxI?e4cH3aC z+1%SfxZ!>U^BXiL9GzV^AZ-O*Vg1+LH@xtE;7`|0=AavgkjJiLYj~gZzL#>>p6(z) zY`&8I`a!E6>@>PAdEH^7p}u^0D=#oogl>H{Er zbEn^+jDWqllVmAc_!Kd`R;xScQ5Xy!u`LZG{^#!=|C$Vse)W>7`CGk!BB7A%zr*G@|OCoZ!(>Qb)O#O0tl;e}susJtjfB z4>Ln#b}SG%6ZTK&)*x({G!)(Su?YhYNuCV?XNhp2-#T_kJscXmpSy2;&s0B~z4IL` z-G)H1N|E@Xbq0b$1hpDl;dDxe&`2RDIKBzuTK11a=*ahfz;~fwLvZOV`6teDW~_1i zlZTk$c>`k?Xf=R^6bkuy1B$pgEpQ!&iZ9oFUqnT+#}fyc^@kNp_RVf|6`1q^Oxk^A13c6>qu5Z zp>s;eO9jz0uncpICCs7!uJp2uUM%${SCQ@T`KcYgFxlb99O*M0iRZ`@kr7v;Rez;( zoa3_BcTMzo0@q2sw>rf-9lwG%o%_}SZ9i+{(s+rMo`YqSo*FOXv{%L}K$)kvM2g(M z^_6}XWDZoX-GlXvm`viN$-O&)`8h=h$lUF!0CwKKdrb_Dnlt}RAi-UjI|}z`E z^{an+=`WTxj=vJ;8$w(Y^|`h(LpW=8FAVliz21ik-S$%^KqK$EVBwyy z{wK~=Pl=om7h#U>gS&*W!<;4wSFsKyWP-wjmYc0!FE%5QD`?4p#4MHo^(tD#b}LY^ zL#ZMzzwLE*f>)J-g)$F0tq0qN0|vVjJJ{z?6P}xRsalzmNs5{u)JJ#+! zz&ud49Q%y9Y9nW!fatSoJ!@7Vw_k!e#WkOX`JiH6M0y?9v*t}})xKy}tg^K~OCA%; zL1|8i*OHM|LVDillgLOvg?V*3LlNbd9dj+OST`dh*{IlLqi2!K%Sdo>IItnmln+FJ z4IvNkFU0vTwIdi)_8+=BBVey_0AdK(m_O*b_x9WnT-JrDBl3V6UT?6|{|M0@i>h~| z-}Pt*Hb9C25Zgmxw4-)!rTQ(y}zul4`hlKc{@&n^qrY z<1y%N(*oClcLq!v-}3BVD6!cO@T(L41H<^Xd6TQI}Rtvopa2hqgdC#mHmhXo46haxyx?~ z{@#Lx4hVkNyAP2x#cAj`!&I&pfnIaIN9#7*iGfh--(Q?D53;j~F0tG8A>t;A`d6ip znCI9|^6*hu@n7*uxQxWGTwnz+;KJtHYLEx0P6J$hQ$BT8@w!W1_Ks*NxL zuluCvk*SNH06VA_hEXuA)9)mRL{(LI8CdAnPVXKJ?3n1VJ%W!oWt~()`IZ>P0=867;K^K+|cm-rd^7zWsh71+L zAR39y5nje1+uNYo1mod`cy4b8JJ1^_m>2@w_FOz{H|QL2cfCFL-VWL!3jv-wx(Cl6 zm`#Hr8?GPF7loEt$JFF|c&k5%++mj)_9 zxPf-?KfG%qSiu^7BLZ2G7Emd%w>DH__$rXg`v_4uv=PYg(+FyKGi$f3dzxwoAyL|0 zg(zq7-28mP2Ebmx5^(P5PuN2iqVV0X8t?cBQz&*y5Z!V#e29G*f*sEPf1+N(9MIni zu8LoT=toAA(`FTrzr=5{e_`Y{fY@-q?zspd0qy~F6HDiY)`zPjH{2fVbj5xJvnkX% zAS+%Xw8OzI7BHbN0xcBmsB}QOrjV}4sDw{x^^_b-v#Mj-C|zg8ggucd#W~;(h7s_% z!RJ(v#P_SArR0TmZMW09X*SS|Zzd`r-q`@wE~3%UrqE#w!|DT{r`7!cwA98Cz}@Y=8aNG_dP&_ z`X-Y(aHgbth2Tu)B97;^DPTBC4+&npZs7`DBouXNqy@bprvNo0N9ceK(HIM=0f=|B z<)@H9hn@(hlunP5B+M=ZqWK9D-!`%dS{Kayxd}e8xOj*WT#mr4DV9WBWL*PS_Op@O z#1&pbG9xY)7mAAoth^NG-vrF>2i`^El+J585d2+ag9U*UIxMK^F(NVnI{^G0T?W8H zR=|>z$Osx6r_fMC_HKRqDgb=9z6*?0FtzyWGo1o62VI|yc-yTe!47;GonyXrnE$s2 ze(F)W%pe;`D3^(Xm+!T8)Xim@WCArDX!lUEpjlDv2pNGb6DSPPER&DLR-~mJgd`?? zKQ7EKPp_|b43ibNTe6N6%D#i6i&tirI1g<^ho8)#4U)qCu{UK)j$#54hKk=UT;Uxg zkr8Q0fbkN*fHm03U^0fmCaDK^pQ?x77Quy#R<&t@0{6Ec>Yza#n2;Dc2IzUh3Sn`x zvF%`XJXXyDxh%19#Kj#bB@CKVzks@FUoB%i0T!Zk*Gd8#)T`&0Ph`85qJm*DKyzvX zQcN?|x7q!t=40>U?U&P0ie+)wvTiZLkxx$}T;MROSd5SmOMzy&xbm9v_5=j(4&Hq2 z=KfE)cQZlS^}v++Eg%fpSwBb=F#_)Z(g=e9k_RDTkf=Tk_fpj&c~IS$u_tDS{vu`u zLC%0r$GmTc=a7d$NL$=}TU~_q4`;jxhc?75hrXsm&KF^lgdGu$_fNmB{RN?@1_(dW z>-g*kBsg=%c^v4otQEmWM4;zTOf8b6p^MJ*%jr%V);S6$r)M_{fSsP}e0Z9+Gs|2F z7*m}K6QNkFzK7&XDZ&&@$CR2+eUio3sW!pMzP~;>LrRXYC5xLxOC#Fg1VN-7&Ylfs zq7jm_PQvVE-XFJ1Z*vV$=ONPVA5SOognRSL=VnACbX$lP2^srif@h@Z0-5HvmeF)94CN;+Jzb@$I}zw9#8Yo}5$V)|sm=>C zMVCxukrAF-dka@c%eU5DQKo)~a`9rNhT0FI+r_r!p+dS|es z+JSnjH_+crd1dU7tBV3fiF-jC51J}KNPNGs=fblHXJP_C85@mK&abVFP2G9Y_^LY; zFancd^gc|0U@YycZU^=|*!d73+}3u=dwW9B)?a|$IvzL2J6X>{F4@dv(g zn2AF-v6hM{bcW1_>47a2{cl0Whh0{=ogLUVcf?%#8b5%bP554SM=3~I8_;WD1!PpW z@6x7=EC>ZQxhqFYZZac#eH0tPml(+jrM%?t6L&;bnFuVzRhl?bUUGIG{Ei~*5?&#~ z3BvwwWGM6@vOaZ)BFu=vNx0~8ML3afo)d>GY8+ZplP9co{Blz3EEz3W56OKHe#Cd- zG@X5KY~xuD&%{d0@wC-dLRxZ686^z|ZJup#!GcJggTY9?HHHfbM5TZ@&?258APMo{ zdGNgwN~LjeT*60AC4@5-9@_Z4X$d{C-3o$TifdSdta4eeQmldcD<4<^pTQoaj8IH< z*iU@dqko$){VqY%htH!9k8BTzF)_7S>NnAXy{O|w@`*){CmlNq*r5InvXc?x(oR45h6YYyHo&JeVo??nI&tUb1$f}c zlKZGu*c;WEg|-AvEm^S##tv)osi;8zJamzR|6M}YDP#=zdY?v|#|87Ey#~u*1$O7B z&HY6X_r&D+H!$2mMxJ3C1Yc*}V)D!bnU*#e=v1d}w;uq1Z|=Q;h|I4vzi=<4Qzh8H z6IV!Rp5Asu8Bbh| zMIC*dIU5mk{Dx*odpGy?|5KXR+pfcDKw=RP`w@XO@P&m@=J6Y4-m0UVj+E998s1)A zTb>xjE0Ov1r-6WL-&*$F6pg??r=QT0J9&?0->lUPyLirhq55;M$+mz`;LYu(#LlLE zE*o3JAMY8FUqxZs&y{Kn7QV6Ltm5VAp;IyKckq__T_y`i{~x4BC1TpibXRZgO~`&a z6&@R}Te#%=W)M?Eups921l5KEyT8UeYZ(heWdTM{dgDQW0moLNELeInoYu55pgxZZ zC6k?-CyB@pI8Q>gVU?k^ufa(^GgnP8C?`INN8z{8|367bD#{lgmZ@0V;Lz!hyReDt zC;*o<(2AZ~mY{jC9|VWd@VgW*rwsol_`SD@b9I>mw@>6EiDmZOv>D(N@nXA=)(L1p zUg&}b8u<7e9-#Oj`ED)sM@yu4D(a-}!ifNqf#@_OP0X$-66k>!A%T7}j|5q_#H$HH zK$?6s60m8c5TVX+f=pbS+Z%qsmNxQTuSwwve{BHfqs*&Mn!wGNnM1ZQ;`9(7JjJsO z#HJ!d0L1%#plBTXy!#VC;dD_iWPLCkig8$C6NcnQ9}J7>&N4uXX0w^?o``vGOF*jV zZIHRulsBKNzAV@bN_P3GdpU{zx-2pwN)X7oBbQ|=Tk4kphpLC9kwd~C@5EWb(`(4k zMVrO=LF~z#-4ZoZmv|Yv#^E4`Gh1USMH)B)+qj8$T6~6rxG~~D^`S@@nCwCt0Yf*m z#_r!^?)RC@Av5L8KS@!{fCM06@K2@3N_;pVo46`OSI(L58`e zgArCmx-8+zamb$e&IwAw{082qhulUGw~df=J}o1pK6#4g3}cjMsLyv!A~?Uubd3S- zOXDRR?6M}ov>nNhoQ2@>5-#yx;cqvbIe?^#Ss3qwxN9Q*wt-LjLDC5tBIkn2$}yvO z9IwV^h@8-G5hdlwOL*{M=|(H)Lw!-N{5j8@<2lCu`rK)2;yv}LdHRwL0T);_6+fQ9 zFw??wA61GT0XWR#ds;+5q`FHtTfU?6JMRN6BCJ&hij1r{OmhhHQ%ss%D*gL&?Vk-}2_!>epw!LnX^1V7hn;POX zvWjnT;E1&)p%4rfs}=AmFEj@2|C`xeZmfKy_#e5Y&!PmLXp<|Rvo8Rlcp;R-UX^dx z8PK^*H|clD2QY75TFU z-juRWu{lugX;Uw$=^~$E1ZSQoPBUKg)Y^+c9dVX_LSyga8+a2?7Gz<55s~~~DZ&^g zOji_D}Q3G@SmaI|DKLeWMr_d zSog#bnnaAe6?swkR~tr&fBf-I5E8I?q+%gNSH1{IwFx=p*YV=~>5;ML(c_WG3E7mR za7(_E!L35!(Qu0=_@*~gkMZFaL~BAcREsepEJW>)P~rtpotyPspe^FS_@NoNS@Gjw zdkV_)nnBD#x$K01dh#V8sh|4iNNR9y&=LSMoB(`#p?ib2-9)cpIQ;c2oFm<}Cx-cd zfw}OcbvTEPhG*Rq!~BXSN^ihO3c~dNAJpH)Ce1)SD;7ch=^3a$HM1=r1NZNuOAYsc zOAAt@M9(~wza4?UgG9*<@e=r^T}(t{+EOiizNgzR(ONRy78Xll1hEA!cA@cku85>r1@7E`}iEvux>HZT*8wXJJv_VKpmTgkH6~d z;?9g#i4D>Gf--nwh~h`n4BA=n>9m}>00F5aK0s`b>i1fyt~g;N(&XQw$^2=PrL1SC zEt(=Ckj~6);K!iYKSd`$aufq1J`S3pExt1bvKgI{`aKCo2C}mjZUrE7Vk^^3=|_i* zWzDia9vOwhD;`05I>N?&z%%*RO#UU41-Q7u)1h{5;QN&gurJ1vFFK(VBh5RXK2GZ2 zV3>>3NLkJ+)>S{Nei}DfZ0)4}iv<1tM*4RS@Odu*H!e?AxU9&9jW+)J7$u>2HThFu z`16t*_*SADD$3Py9!4Gfg-H1eTk>b7m`6!TU_U$K;op z{0bAghQ$G)zR%omGofxI;-?}%R-`Yoo~ezNEvLd47jMAagsHp&@f9`@Bt`s1GXCYQ uWoy|v;Z&ZloUfdyY*n7AoT|J~SwmW`6f4IotCdTYLgjSjTICo@$Nw*Nh(K@v literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/ops.cpython-38.pyc b/featurevis/__pycache__/ops.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea3db9bc0d40732d4948281045c19c1153532588 GIT binary patch literal 21101 zcmc(HYm6P&ec!z9b9XP7b&>`M3N&q=P0@bohay0M4qzZfKP39n4{d=0 zK~wej`=6P)kG)Howtx;f=bm%s%z6Ib|Nrcd&&`z$Tz~%Emp$vIVf;51MlTzMtGL5& zn1r(w_C+_X{982r&VsxtjtJ0 z*P3n5t<0ImYlffq3-23#;jXn(L8<7MP%5Ex2&J+=gVGF2^C->wb12QBbQqR zC>=p*-am}eVU&)dbi_Z3(ovKaP+IVxK=xTgntsHlPDcW>6CvO zrPC;#Kv%2Xj<&a2QS*+cnqCytI$hP4>LO}9wbty^`Qqr6 z9rZcX2F8l%8#rPU$6N9pKli@5;siN;On1$dykErd<+yUI8+omFWSC~R<5d7BuGG1D zY*e}`Sleo$N#Bc5Tq>7cT%S{GTkW6|g;%7=s_me;wjQ~QjaJu-s#n}E>Tuvki|?%mctN>Q*WC&Od3o5Vt6Z-$Ec!vC*=cfKF2<3WXY*n2 z+0vHWSAvFzO~rs?JuJ2^zrg+F`<&;R^86+iR$Y>gKERF`H|pHp^kUw^eI0i=k7QsD zjG8g9kYd|!8V}9osukz;e#E70wpBZJ!l2bqCA_4Fx(^LCi=V%K=98hSf3gvH(UuDC zG{ezsw-+w;cH?5L#+BA;$M8bvATi9m**`vhf=g+uI%k+(d1N@I%yS6!#;`CjMak{==u}J19Q)s^5*FK&Xo7{80-a4r5Af(Y*^~A(3d?(#~+=G z9uuv7`=~J>g&NLNp6MF)#}>yiv-?hz8<=-Z-+Ex(&m%SWoX*98wZDE~@2@*<>^YcI z0W&HNoCoHDv6ma3z+|p_(&P82SUyp5XHIzfdp}wc0xS)b?-RlLh z-3mIf9d5PdoMWdQc%5oq&EW0W+*v93%|;`v?WUQX*oyANPOBS+0t`BtV{4pw-D|aK zwNogCXOI~774rtp{hWFB!@QX{tPdU2`Y>-_H0P};u%O=tG|DP&JS?!wj@J%qwYXfX zwY&aSi}~4F?Y%9pl{_ibYJRs~tEmbGR5>Q6nGjS*5>8POwAd^xA}N|qq3l?u)Yefk zb`fu`;tn5+MCHHGTLyaefAM;^-P?+SP_VSs%aGRVxXlipd_06HqaHnXu?Z@01$1Lg z1%cZDFEn}3(7{c3JQAU}T{sqEWo-7Uwt$Bw49}u&a+|rumv9de|B&97 z=?G8qz*`XhDl!^vAAnG8SVw_&kt4`r0$Fmt`2c9cC#Q|0#vXHdv@Z;RL_h?4U;`2C zWpxPs$aTzEBRKB8>a}&lj|dVeHwSjtu!ov zv)Lc6a2$-)Su|0^hLK(bHU%P|!GkL96e9Bik*uxb9=o_jS8<2j+A*eS`F7xJ)<(c1q^qA z&Tg>dwRhIiDWaT?`{7Jk^WRs)Vm@uLm8sE=bkvthqg} zskWQox7pmALAd0;h52s_USmPi9v+&8^&Gw?_2hI7!3!)7PAg0122u=m}R z;kI=L2@dm>^y&m_wP35>YWkp{SKQ@b4P)NneB7+s^_yYjb?Vr~AleSFBqHhbKC#$U z%%Ro=Za20%b&3txn;S`%(uPl|!&_Txb=!f0=ykxhWK@C!xr@ROmZG2&f=J;1GENm8 zb8Av5M(?)Qsza2DxZmU3{OV3Gs7HaHb<91$R8|85$xmFm=w5!;RbFQ;fbin8dR28j zzwTl2tF6G@Zbs`V8RV;ir}50lNiEk&$kU5?0IVhuM5R#~W&r+Nvj*UZHSpe>h9*{y zCRTY3SaEr{n_zKRX*D-O!${)Qc_xcYhMYrCl+^6=xCKQi#_(VN=n$KxQ#HOuZY)&o zKBgaG+F<$SrlC$n=6#E7AF2uH6=)cyzFAa@1G7`);x=s1GD`#k{g(5<0&O#Z!$k2?47S+1MH1F;eQ2X+J2OHugBD;)bJF&@lbt8U(WYa}S_Aoj~hfwSEqw z5`+?mqK=4W7DOv4QDkeNv>;4Jh#$$4{}&n1^1yrevp5F z-SbPw4a~0eb+bc(DCd`DZ~k#q*qDbP=J+%Bti7`A2KGqrhP+=Mlpk2>+nxU)@6O7* zf04YKtRq*~GU9x6*st6_ z!f|QLJxabceCdqJQWf(oJh`W?i#LxAW^vkcgE_E>`DH}~ zp@03YP74GN^sm|WfWyFPk||C2-67mhXh}fpR!ap?3Oep3MNLFA;ZGoU>!BGJHiMw& zH`{{kfBB35`P^U4EFFG1&ew(3qJfQvD|2IXbj5CmLI2q6ojV=~YswQS`Ca*Yd(b?K ze$!inD%h$X7mgkmw>{MX#R_AGIYH>yxzh}`m0&sfyvPHw)o#aTBqBhZ6Iob^V6em% zN0G$#TA*TwQb1gO$7^i`uPW75aUQ}|+lyicta2-Muuq{T9u$wNl@S@Ds407G2k(H8 z)^=7(5WAZ`gx4_6b)b@}6&r%|iZrZI2OebSGO z%ByV3r<2mp`-T_{XgZ+8llSug=R%x+qZvhk>fdv9M!;CZGz1JVD8JiwS9jeI{L`%m zD)Ip8Uc0;1d4zn9rPVg1-^FMPf)N=!WbaT|=uWe})lRzL1Kp4qw0qIr(Xz&vvP-tc zr3sfHYa{MP=3Prwzzg!AyJmx`I;d#M+U&U8gmj_>3Fvp6L|h(D3xYbeH}wjWDZK3G zQLiOe0E6{m|B&9C>0FF@Kc!rm-~U1;GB!jm_sx@_LZBc}#-Z3+$HB?)3{>}?bKiLY z?v=F!^-o$NH>D-jYI8HEeEv49PSH09)(p4?IEpP#{yu+`C$>DvMY#>`4tU!ySrmHj z*?TB&Q0#^JebV^5)?NX83$`Qa-BEuQv0oVdI^_s;Goa>oE$QD;e<9C`$uo?=XEZPD zl?EjW&&!&gk)KyhAz+|aIX~Kk1`SoZ(Skhm(2DJz=R>~e`oRbP7drS7a76H-Kv)Bi z$eF}B@=eQBA{te#Ue@EL)N~r_594f_=nv%`?!@M}Q(xXAV|jK8Fr} zhMgu#b*@OInzeP@V;3R)D(?MCbF!eeNZ$RZ+-X_G#6nmkk z^itVegmTTZ4%ScB6T6>Qmp?yd^Mu$mvAVIH$i4yzb!TLa%oC>t zU#MPEnoG@XT2vjyGVe&;LQ;_+0P@f>P7E6bFH65XO zNSRprn$I^HlW;>Y2_kCPtfqkxEWl8 zdX))P{iW)RR`b8WnyXBRQA&1DHt$UqxtFosZ}#H6*XsoxKhEC)A+2x1N+3j2>;60h zAXr|0!Gq;cVynK38%&(V-a+{Fdl(|*$s6Fa&WHIVb-;VUTfs}mPAD}NXrgj3lHEdo z-)7GVlI6=eAQ@{P1IY?gkqpk5YB8R@M!i1puM_^fcLBrhbp;bIaZMyYVwvniif&!i zgl*qz{h%0^X_4Op!a-Sd!zk$0!e&1Z+@uC8ED-#6d8@q&Q#>ZxYwiRsFZ`9w!*LpL!PM90Han@YvR&#Vjkf{(~AnW zXzF*mlwqNLLO|7yiREq-49yjjy*{w9GoDg5Snloo?jzTFiihX$_xB1LWOE00tZ|q~ILtZ68CW-S~$|;rGbMMPS%2&ud!KD zKNsaU3hWa)B4rR8dSOoLXg`GEEU5!oO0_)dtb@FaQzXT%=CpPsf&i73F!F^4fyWQY z^fk;~aTReX15pwAy)zcXQr8`P_viJW38Ld4+?sC*Z1Y0XLORxs810nYIrV)Nx%GfoM zaM&|mLc1K>f#6#a`1fdgXvwB95{Ts|jk`7&!L2N=USGt|L>@W-n%h7ur}s!SNsxW#T=MY zPTN>;wq@-&>7Utg>p<)-_1|@m#yencVgOxI!gk1P`qdpbT<>nR#I^;KDilRvEZ!u@ z2Z?n|h>U>Cl6nDeK|aj;@Rvc+plVh$t}*V#QV5kE7SkT*qFo1z@CWf%mf} zy};{ml-8wIyIf=gNqBZ#F9hjswYu9Q-rr8JUE6Vg6n4$EHi+`#PSw5OF8WZ;75F-I zDfb1?x}?nfpsFrMrIbiz#|K?EViKZ9x7Vhh~r+S~oS_{m`$=1n_ zxAQP@Fm>^k>M@xBUD{UvhFyy2O>^wR2uMt)bDRoqnTm@H1WV90?PVfup(T^QaIeDh znrholqQNDQqNl@&rCu# z%Lw8TLb+G#7v*OgIH+K6@fXKB1uk}5J{$38yPAYI@MUz4`PN|9U+?;v{z z+0j+59Kw{vx0b9Xg{V6?#dvOPp_7nB1UQmG77^gk+p;m!VV`J1CyKy6`9x$ynx}); z66P16Z{L-GiKL#=&#)dI*bM|MP?4iG3d*2;kA7AJ9Ar!pc9A#GGt6!_wmr_tv1-P~ z1*x}?#KkQr7j!48ZMGe8xW;7x3(?0{O3aHoFu8D|)G;ocVvAv&Fi(swJ;5hTWeZOa z=1&oxB6KW6tFm}qS$i;A(Kt71cMKdKB9Ry>AV5+;j4Q7xZ&!}^R`>1KuJ!+xdn*%r zT@TErvj(&vo9YCK+C&iT0#oR;PacGbEuygB+f5aLfx&C;5|63 zV}PemrXwJ%!-TNGx*zB;i?379fwR27I6Ov5d9WOdlS2y{+UNusqZ#f$9?VG}4>x%L z6Na!m4bxvj)img?av|iIhSfiu&SAJg>Ziuvlg*xE-ItM^pV$S~9lQ(Y@N^WU;VGIH zeMbX9DL#4&Knkh1<$s~M8MK<~-LCKbM~nyID|sLkAHt zTVtMgk>3F&*Kvoxj3iOa>1~J2FhX=1*a4i0$mMX;jz`7;~oJF9cWQYSqO5TUT0kZ%-J%Ny;CyhNL zvOq^|q*%S=oygjNI>`_ueJ6oPFdA?yZLAblNe?UH>o_3X1%3m;w7taL*y^suR<8*n z`z+rfrH#$D*5$@&D&iTuRsw9-iSj%r0}9+R`0e_aGK3srY9<#fz0~UBebIP z`8tz-$mFX?;6M%9Jw?~SBpsx9^TS-1sHPHdaSqO^BL3y!n=HaBnKz5M{+UOubnJl1 zK)B}u$Q@*GoQ#P8gM47#Hy;=}9s|cp`G(OJ{LQJC#A*bPq%m9~Bkax+L3Sg*NzkW- zNS7cTEg-lPHVYH>iIMgakp@YLC$9nFdE{XFp^;c0eQB!`zPA+wID))_i4A(b?3(Nq zw=M}+iOoI_A&gdvg7ki^zfwxjx27g{k&O2Z?jnK5fG;<1E?7@7SnYs)(>xf_bIZ35 zmYwdRuNP971G6ob7r<^=TjwyNmyNfK%m$f3d3{zqMTdpn$t)w436UiSPLMcrj zLG<}tv~8_xU!=KnXwM;GrtQ>4WGuOh7iN@~3dliTT(a!zTrBB`CX+)?kEwnHwW(*8 z`N_i~$iK^NWj_Yui-!A<;qDkj6Ph#e?+p~h--@`R$WEgr5hiVkEsT~=z~^arYxPrD zNNtJXaUd{?=F1o!*u!-EB%t*WdK9yjHge{)cSUASSyS7tNTSAs`23E9{}YP2$&-sD zMBe5iwe)_WJW={-D{ckcWpr@@hVoajl zozVgzBH)@08ve!7bg;5KY7(Nv(%puwP)D;!w?olm)Nq5ApU3wJ)0)CjdnM!?g~*_ybMF-V9*#0suwPBAq=S(+-xSu;^|JcdY~~WYpUrr03Xq%FuOyANQ2nfMDHklXGW82k|B&yWuixhkW)E9TuhgovIEN1lNdpE@DDPKF#9Jbfp9u@&fqnM zp$T^WA7o$$fFzrR#2|>2p{Ef%{SZ+g&-(T$3CTeXYy$VvC#;1VC#iL2j5UZ!WFYY8 z^Ib^4%uv z`itlv;ii!D>BcFcR2mcqCCK_E1gpYzgD_R-1k!E}p^U`^j4`@OzYO;d0z9F#&Lrk3 z2^A3W>s4%tmdMH9=r-YX6_JE9Fz~{eT|=BsTQyLL)A<$rtjs14C?JOj?-SbxNt7`cF?^1TZ(<)}I>hMfww4&adOaudpi$N{K~_b^A7z zeETZykdQFCsbjXBl6*@Eg%+WawC0rK@|&8M>|WdLe>ctRP1VtmppN)b;Sq6=h(-vb zEaqY-ix=3>q(~(FpziG^J_CMUAzw!^q5-s5M>inG0N*gsHUwkZZT*B^x8Zwq(Pgd1 zDE$lWINBN3>0}cLZ+MRrp$H*qu9t`Z~@N^8=#S$+uzyN66<`#(p;e@LXK6!9G!xIJLf19OT;5gek;@z;u0%GK zuZ27}Z3aSvxb5wOH7X=s;xOO=Y7Y1ECI34s}{8O8pg z=QE{ddf;i)Oh1{VW?8o+kVDD_iT+?}#-@?NH(-p+%S7ghy`h0OZRERNg90ox7x;Cu z067wOZpPRgvW<~Q0|{rNh`fYvJ`imO{dY4^^j!U@`x(&UbWxYHJ{XqF;Ae5m0^=ae zzsX{{vkX*5wf=N1t;}{ApTF}P57COD_o$J;IIjAW;B%b$)^k|6_8NnE% z7wm_mm`e+3HPzBEg4gY@(hEpdaRxbr(|1lq_D>r>jZk{=T^3pUigx`v5xz-}@(7qi zKo;r?+9eDtI78(STIC~R7qT`(xugw3?ybFi_7)t;6K@rgx6o7a7TU;L#i)#sECz|q z;-152YY5(#Ivm1CT`{U`9D+rI)_#oMa4^C=^a2}tL1p7Gr2jlVf5N8$klgU6BjB>O zwe&Af%Y$P26wmo7L82Mpt)uw(t;lqNACS!qW^lOB7RVs$*um@~#U|K%3U}xt85r-L z*n=+sGcmpjs;n99I|d?^!FCBE(h2@bh8#D1{?^i^*bE<9N~p64`f~D=^WxG=Ye5Iv zq3F2j@;eyq-*a3d z9)y;eGCy2mEq8A0;(lJm{WwPOk~aR{jQqbIvw^2ndxV97DkmQ!XJmMq(=7E@_V%gM}yP zJwX?!KD32jnpkqGBvM@-c{w8<>R;i({~iItoCs&E{aAo7iL$&Ic~Pi-pS=>4(~EhY z#&z5WNA}^oZ=-?e%&DlFRg5f3keM8CmOH|e6=QS~)hAP!4g@65)RAQxUqfa(5HMaz zK3;)$ZdB=~heV!1O9F!sF?*QmKLI0pmE|Mec+7v26VS=Qf07%54%(s}zk~)W$ZG() zg-sxMDAFi31f;wsu(w$|1SGL82s9;MsEcI(uhD1)&J`LvU_g{u1K6pifYdxUP-|vq zKm(Vvn8S1vKN76|0AuCTUO?OQ_gt*4;~u*R1XpqIk2!qQ-*KALi2Wvvxu9?YS~rA` z?UU9p3w^R=Eu*dtk;xEPkUAS|4Q7jI7F(-psn~TJWo;wNW6x@7MA0z$u)sgBBV_Hz zFyULOid1{1hk#kufXO|V%@dQR-ryme3Pk@2oBT17bi=j%fM)sxR3%I5_ixyAV&h2y z&vN5gZ{QQ;CG!%*-cx3O-}Wa^TeUQ#9PFO{BlL8feI}eaCm%|&_A#LMQC}k-8ikCM zG~PHEbVV6-UeRzmWrI^l#fQBIa_)bJ4xdj?izHUWN7h!KQ*9hl}nXFC@=g!uga+j literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/utils.cpython-36.pyc b/featurevis/__pycache__/utils.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81387c2ae912ffed83aec019f34a7735f857be8d GIT binary patch literal 3602 zcmbtX-HzKt6rLG7i8pPRrId<7fl>L}6bML2y+Bp9)fTt_EfobSR;ny-JlXZevC|o+ z+g)X^wy4Vml@PDM4X?m!aOW!|u6PBm_|A;&B>YGSEX~-NpL5QfbH49P-aB`$+x_W> zd*d!+zp{nL!}kW7c^6&GVxF>X7K_+>#J2fIEcWBpBNn$##J0e%cHF_Q4t{wtzr%XL zZ`j4Q2Ap1a{Hl>uvx6??u}IlB+`joSKjr)4l%4Q>Z{I&*$Iuh|kJwDy!q_*WXg%gb z9=9+SxG{`+Grr%ZJ&)OA@z@)B){5YSAA2*8Y>0k_dU;C?avc@9mPIbd(MZWi4yW0m zNb*cZJE@}aWH-yTl36rXv7AI2??P!Kv%HY88l;iNc#_GaFkMMctcFRJkc@uUj@;C{ z)3M45^S)bvHAA^xE9$*3Kh?=@l0|8wyxRDMiFVa|6A9mV01Gr$H=<}1D&_bv9Iij? zEib3ZS7g86ZHza>uF*N9Cvc#c~V5%+wACa9jgBIG#^B% zxq***VUzx}m>}>B?WFD2#PiO?Q?`%f9|>owHL2&7{wT@fa^-fNi{+UwZ+;ej{J~du zKmF`hPiPXSTj+4IPLi348WiqKZJOzzdjYMobAV6#)XsVtzs&3CPCav(05lW?#YX|G zVJFPOj-B!uJ7rG@(B87Yo5Q>W5efPGA|2+GkJ{QlWix&W?R)F{xuYwqOFlvr+Ag@| z8H=`%Vq@m^!`&2h>+UOLYUS>?|LX1o9Ze=mFZjRNNkJc}Lj!d_Ww|~FQSdDv>Q#J| zPgMzL!U_f4uF&McvQr7B6B-&}!WYl+qf7s2La(FG(9RW$`aDlfxnjU9Hm}O=oL0&< zkU3SR^rGyrY>^_<^EKtJewHKz!_cla`T~v7;p=(QV6E4bOwQDxHi^Pw*3hx110Hy5 ze3hT&UGaQJU&dII1hjx;ZlIZUbPAjvvu&gR_}g*3?-+i&<+y#j9S2B*m9n!52;@dZ zl-zQ2F9It@(x^h_LzyEG5s@O$pMh2}0p0+`);w5o-UrcOuNjl$sVQpg%REyO@-4N3 zENgO*Q5K^e%4|B`QJRz?vIn`2Etk~GOkXa`21x;xDLCaIDfTRb<V#h?xz806jC->Hl{h2@W z>iPTE?lN1Zy)DbXiW%RP)$ng(e;b?qDd2= z3s!s)ctO{WE;^6Cqg#Z!^7mV~RuSMi0B)~z+noyV!2;lSl1v@_B5zJm&Xqwy z9uAeJtHnI!=oS^>f|L=q2&~|4+GYVI9p?TM9_A{VTSFx}%qL4XtPks39c~pd*;B2v zz|_i2)578u+2XL;uvG;$auhxECNFQISvqx4n+X68Jn8a7*!(EFb7Oj*%@qea^7TT{ zsDRjzenK({PmH%6?8r-V*bxlqp(O;pr_js>x+U11Co534Im$MLFCef{(Z=1E?TZ4p z=oxO}vHz_&LHV{ew;a%xE+wRa>WI0B&R$AZZ5>DHf5I0oB=#irt>ZPU#rM;Axq3Oz zNV;}>j#k&}S2tZ2;Cv2!3uU^wCV{)WI2i-*S4gDgEOKAj!mWLuti$Z8VDx;sjq@T=Mw;-~;^znPSg9KRiM4E-9oT#*c^ws^Birz>4l+ zR$ry=P3qpFj{aqpo|%sS4esB@;#+7A_ibOS`awt2D4ax+Y`M2YU`H1WZLBSW>yCkL PP{!E{4%p+>)ysbXs=!Ii literal 0 HcmV?d00001 diff --git a/featurevis/__pycache__/utils.cpython-38.pyc b/featurevis/__pycache__/utils.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc6d8e2b9f0f1aeab9f52737edb345c24853c736 GIT binary patch literal 3652 zcmbVP-EJF26rPz~+Z(rp5};5hFti2Y3S53FE~=_Zl>ib&1+|olNY!fN9VZ*FciowF z(?rfyiyAJdgm{5e;-;^_YjC$$NL=v>+`xBce{8oPAy%64?wOf$&YU^lcg8oKd8W3jg)b-M z*ICE=1FP889;cu3aq&xyG@A`{ArD2&zUTIr@ACtGC=S>ozU>^kkJvtJh3Nvf4hf}slKDA4%Llr}O+Ga0I09B9a+L`IouOL{`pkCKRV zblX;PS#OSqD#^@+Vgly$<#J`Hb3uNoqs=G@;@Wt*@P-LC)pQXlU%3MhG-lVTND7m3 zxa;?q?{?;=)8J{@?RM+wk&){5IJy(W@Cf^>2j=y>E6<)C?7))wCylcTZ$zKjY5cQlnuS8yQ4Vj;U(J&AcpgDCr#eTYJX?}>=%(Ebt<}3 zM4D_BzR57MhZX4EVuzYCYd*h3nOoN>zn0K#vI)D@-scm(&3+WO-RtZz>+syA6Migm z(S1MXBTdU}_vh(zM)%J3RgjIfx)Yh%*KrobraRir+ZW@=WZ3fP(ko<$GP=nG+dEku zSodO__JY`4!b>%E4hUqCmOW4FNr`oIsc`gwZS!q05QW3mv5u3wgD45}g|Dit%#VC? z`I>*_lW%W+d2LOTGHk3BC1#|0S+S)SgxW**Dq8Jk4bj zm-9hKuKZU_drD&GPn?Y4Rq(I#wokf@C*ukRj7?^$S?6UqZL;^?f_r=;I`#T^x%kU-JigS_uR%VS7BrD`ub`P_bPALovUMZ{=)EWb zZczZ%8wK^RH$xAJv5>b`fsE9sfHGdLZUrFBKpK_Fv@cT}NI-lEVo1Qa7yzY!eJhGA z>F|@Fw^hsJaBQ-Q7G#jr-T zsxjzhC(5=gxuxT5G`8*%{fvkS(y_6Imjhz7g8l!&iB91~99On$_prQQD6a|tS^f8_ zF%zg|;t-UMFYrTJs!*AN2YYl-)kE*pR?!TV_X#lTqk4n+_|?ZeZ%-8iajsEuU%!cY zQ%IJXwu(DfE#3b?oDaVpR5a^$r=d?ll=Hh5 zpt*yy%SAfF>GgIf-oF1aIY&@ofIw3$@g=?}W;a$$o7>paL1o*P&8{;|#Hl5^$D;7W zjWRWSGMYzxe^X^N;`=L@Tm|&`X+Z1otDRQv`Ih~BKX3c~Fb&7C!uwI*zda6O;zfM5 zd_PQkzOPS1q3%%kE_LMXOlOM#Q5C`1a;C@KHh|yOB<-QiJr2HB&`cNIEbNuL-N5aO zz|R48d;42&mEiYgz`qeCYVS9Bd4#I34C;2juQc62rm07ltpN9^gm6Z{1*_9C3ocpU z?|)%qYNEbel&bx7G}ln-d5f)S;gg=R5A?BI&ybJ704 z%%IPb?I|p+HG=9*vPN>o_lOC~Q=MUg1^pgIH9=9IqmKTH>GSAv$Bc*n1^ORg@)}wN r{nn!EwKPc)8q#E|zvTieopIEo`OsYgp& literal 0 HcmV?d00001 From f822e56e61147573597f72d41c6fc6e9e7081a2b Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Tue, 3 May 2022 15:02:26 -0500 Subject: [PATCH 4/6] modify ops functions and add back accidentally deleted loss functions --- featurevis/ops.py | 173 +++++++++++++++++----------------------------- 1 file changed, 64 insertions(+), 109 deletions(-) diff --git a/featurevis/ops.py b/featurevis/ops.py index 4f88715..ce64ab9 100644 --- a/featurevis/ops.py +++ b/featurevis/ops.py @@ -93,7 +93,7 @@ def __call__(self, x): numer = torch.mm(residuals, residuals.t()) ssr = (residuals ** 2).sum(-1) else: - mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.reshape(-1))) + mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.view(-1))) mean = flat_x.sum(-1) / mask_sum residuals = x - mean.view(len(x), *[1, ] * (x.dim() - 1)) # N x 1 x 1 x 1 numer = (residuals[None, :] * residuals[:, None] * self.mask).view( @@ -105,9 +105,6 @@ def __call__(self, x): sim_matrix = torch.mm(flat_x, flat_x.t()) / (torch.ger(norms, norms) + 1e-9) elif self.metric == 'neg_euclidean': sim_matrix = -torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) - elif self.metric == 'mse': - mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.reshape(-1))) - sim_matrix = - (torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) **2 / mask_sum) else: raise ValueError('Invalid metric name:{}'.format(self.metric)) @@ -169,12 +166,16 @@ class RandomCrop(): """ Take a random crop of the input image. Arguments: - height (int): Height of the crop. - width (int): Width of the crop + c_height (int): Height of the crop. + c_width (int): Width of the crop + n_crops (int): Number of crops taken from each image in the batch + x (4-d tensor): A batch of images to take crops from (n x c x h x w) + Returns: + crops (5-d tensor): n x n_crops x c x c_height x c_width """ - def __init__(self, height, width, n_crops=1): - self.height = height - self.width = width + def __init__(self, c_height, c_width, n_crops=1): + self.height = c_height + self.width = c_width self.n_crops = n_crops @varargin @@ -183,12 +184,9 @@ def __call__(self, x): dtype=torch.int32) crop_x = torch.randint(0, max(0, x.shape[-1] - self.width) + 1, (self.n_crops,), dtype=torch.int32) - crops = [] - for cy, cx in zip(crop_y, crop_x): - cropped_x = x[..., cy: cy + self.height, cx: cx + self.width] - crops.append(cropped_x) - - return torch.vstack(crops) + crops = torch.stack([x[..., cy: cy + self.height, cx: cx + self.width] for cy, cx in zip(crop_y, crop_x)]).transpose(0, 1) + return crops + class BatchedCrops(): @@ -298,46 +296,6 @@ class Identity(): def __call__(self, x): return x -class ThresholdLikelihood(): - """ Threshold the latent space of a normal distribution based on radius or likelihood. - Arguments: - size (int): Length of latent vector - radius (float or tensor): Desired radius. - likelihood (float or tensor): Desired likelihood - fixed_radius (boolean): if True, always scale to the fixed radius regardless of original distance; - otherwise, only scale to the desired radius if original distance is larger than desired - """ - def __init__(self, size, radius=None,likelihood=None,fixed_radius=True): - self.size = size - self.fixed_radius = fixed_radius - m = multivariate_normal(np.zeros(self.size),np.diag(np.ones((self.size,self.size)))) - if radius is not None and likelihood is not None: - raise Exception("Only radius or likelihood can be set") - if radius is not None: - self.radius = radius - temp = np.zeros(self.size) - temp[0] = radius - self.likelihood = m.pdf(temp) - else: - self.likelihood = likelihood - def cal_radius(p,dim): - m = multivariate_normal(0) - p /= m.pdf(0)**(dim-1) - x = np.sqrt(-2*np.log(p*np.sqrt(2*np.pi))) - return x - self.radius = cal_radius(self.likelihood,self.size) - - @varargin - def __call__(self, z): - # Scale linearly depending on the distance from origin - dist = (z**2).sum(1).sqrt().unsqueeze(1).repeat(1,self.size) - if self.fixed_radius: - scaled_z = z * (self.radius/(dist+1e-9)) - else: - desired_r = (dist > self.radius) * self.radius + (dist <= self.radius) * dist - scaled_z = z * (desired_r/(dist+1e-9)) - return scaled_z - ############################## GRADIENT OPERATIONS ####################################### class ChangeNorm(): """ Change the norm of the input. @@ -424,18 +382,20 @@ class MultiplyBy(): const: Number x will be multiplied by decay_factor: Compute const every iteration as `const + decay_factor * (iteration - 1)`. Ignored if None. + every_n_iterations: apply deca_factor every n iterations """ - def __init__(self, const, decay_factor=None, low_bound=0.0): + + def __init__(self, const, decay_factor=None, every_n_iterations=1): self.const = const self.decay_factor = decay_factor - self.low_bound = low_bound + self.every_n_iterations = every_n_iterations @varargin def __call__(self, x, iteration=None): if self.decay_factor is None: const = self.const else: - const = max(self.low_bound, self.const + self.decay_factor * (iteration - 1)) + const = self.const + self.decay_factor * ((iteration - 1) // self.every_n_iterations) return const * x @@ -448,8 +408,10 @@ def __init__(self, idx): @varargin def __call__(self, x, iteration=None): - return x[:, self.idx] - + if type(x) == 'tuple': + return x[self.idx] + else: + return x[:, self.idx] ########################### POST UPDATE OPERATIONS ####################################### class GaussianBlur(): @@ -499,76 +461,69 @@ def __call__(self, x, iteration=None): return final_x - -class ChangeStd(): - """ Change the standard deviation of input. - - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. - """ - def __init__(self, std): - self.std = std - - @varargin - def __call__(self, x): - x_std = torch.std(x.view(len(x), -1), dim=-1) - fixed_std = x * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) - return fixed_std - class ChangeStats(): """ Change the standard deviation of input. Arguments: std (float or tensor): Desired std. If tensor, it should be the same length as x. + mean (float or tensor): Desired mean. If tensor, it should be the same length as x. """ - def __init__(self, std, mean): + def __init__(self, std, mean=None): self.std = std self.mean = mean @varargin def __call__(self, x): x_std = torch.std(x.view(len(x), -1), dim=-1, keepdim=True) - x_mean = torch.mean(x.view(len(x), -1), dim=-1, keepdim=True) - fixed_im = (x - x_mean[:, :, None, None]) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean + if self.mean is None: + fixed_im = x * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + else: + x_mean = torch.mean(x, (-1, -2), keepdim=True) + fixed_im = (x - x_mean) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean return fixed_im -class ChangeMaskStd(): - """ Change the standard deviation of input. - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. +####################################### LOSS ############################################# +class MSE(): + """ Compute MSE loss between x and a target specified at construction. + + Arguments: + target (torch.tensor): Tensor to match. Broadcastable with expected input. """ - def __init__(self, std, mask, fix_bg=False, bg=0): - self.std = std - self.mask = mask - self.bg = bg + def __init__(self, target): + self.target = target + + def __call__(self, x): + return F.mse_loss(x, self.target) + +class CosineSimilarity(): + """ Computes cosine similarity between x and a target specified at construction. + + Similarity is computed over the last axes and averaged across all axes (if any). + + Arguments: + target (torch.Tensor): Tensor to match. Same shape as expected input. + """ + def __init__(self, target): + self.target = target @varargin def __call__(self, x): - mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() - mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) - fixed_std = x * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) - if self.fix_bg: - fixed_std = fixed_std * self.mask + self.bg * (1 - self.mask) - return fixed_std - -class ChangeMaskStats(): - """ Change the standard deviation of input. + return F.cosine_similarity(x, self.target, dim=-1).mean() - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. + +class PoissonLogLikelihood(): + """ Computes (average) poisson log likelihood between x and a target specified at + construction. + + Both target and input need to be strictly positive. + + Arguments: + target (torch.Tensor): Tensor to match. Broadcastable with input """ - def __init__(self, std, mean, mask, fix_bg=False): - self.std = std - self.mask = mask - self.mean = mean - self.fix_bg = fix_bg + def __init__(self, target): + self.target = target @varargin def __call__(self, x): - mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() - mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) - fixed_im = (x - mask_mean) * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean - if self.fix_bg: - fixed_im = fixed_im * self.mask + self.mean * (1 - self.mask) - return fixed_im + return -F.poisson_nll_loss(x, self.target, log_input=False) \ No newline at end of file From 253717afa7e904d7744fb42cdfdb7d96897be29c Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Tue, 3 May 2022 15:05:34 -0500 Subject: [PATCH 5/6] add gitignore --- .gitignore | 112 + featurevis.egg-info/PKG-INFO | 16 - featurevis.egg-info/SOURCES.txt | 13 - featurevis.egg-info/dependency_links.txt | 1 - featurevis.egg-info/requires.txt | 4 - featurevis.egg-info/top_level.txt | 1 - .../Untitled-checkpoint.ipynb | 6 - .../.ipynb_checkpoints/core-checkpoint.py | 260 - .../high_low tuning-checkpoint.ipynb | 18445 ---------------- .../.ipynb_checkpoints/models-checkpoint.py | 114 - .../.ipynb_checkpoints/ops-checkpoint.py | 562 - .../.ipynb_checkpoints/utils-checkpoint.py | 88 - .../__pycache__/__init__.cpython-36.pyc | Bin 153 -> 0 bytes .../__pycache__/__init__.cpython-38.pyc | Bin 184 -> 0 bytes featurevis/__pycache__/core.cpython-36.pyc | Bin 10935 -> 0 bytes featurevis/__pycache__/core.cpython-38.pyc | Bin 4408 -> 0 bytes .../__pycache__/exceptions.cpython-36.pyc | Bin 381 -> 0 bytes .../__pycache__/exceptions.cpython-38.pyc | Bin 393 -> 0 bytes featurevis/__pycache__/models.cpython-36.pyc | Bin 5070 -> 0 bytes featurevis/__pycache__/models.cpython-38.pyc | Bin 4583 -> 0 bytes featurevis/__pycache__/ops.cpython-36.pyc | Bin 21895 -> 0 bytes featurevis/__pycache__/ops.cpython-38.pyc | Bin 21101 -> 0 bytes featurevis/__pycache__/utils.cpython-36.pyc | Bin 3602 -> 0 bytes featurevis/__pycache__/utils.cpython-38.pyc | Bin 3652 -> 0 bytes 24 files changed, 112 insertions(+), 19510 deletions(-) create mode 100644 .gitignore delete mode 100644 featurevis.egg-info/PKG-INFO delete mode 100644 featurevis.egg-info/SOURCES.txt delete mode 100644 featurevis.egg-info/dependency_links.txt delete mode 100644 featurevis.egg-info/requires.txt delete mode 100644 featurevis.egg-info/top_level.txt delete mode 100644 featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb delete mode 100644 featurevis/.ipynb_checkpoints/core-checkpoint.py delete mode 100644 featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb delete mode 100644 featurevis/.ipynb_checkpoints/models-checkpoint.py delete mode 100644 featurevis/.ipynb_checkpoints/ops-checkpoint.py delete mode 100644 featurevis/.ipynb_checkpoints/utils-checkpoint.py delete mode 100644 featurevis/__pycache__/__init__.cpython-36.pyc delete mode 100644 featurevis/__pycache__/__init__.cpython-38.pyc delete mode 100644 featurevis/__pycache__/core.cpython-36.pyc delete mode 100644 featurevis/__pycache__/core.cpython-38.pyc delete mode 100644 featurevis/__pycache__/exceptions.cpython-36.pyc delete mode 100644 featurevis/__pycache__/exceptions.cpython-38.pyc delete mode 100644 featurevis/__pycache__/models.cpython-36.pyc delete mode 100644 featurevis/__pycache__/models.cpython-38.pyc delete mode 100644 featurevis/__pycache__/ops.cpython-36.pyc delete mode 100644 featurevis/__pycache__/ops.cpython-38.pyc delete mode 100644 featurevis/__pycache__/utils.cpython-36.pyc delete mode 100644 featurevis/__pycache__/utils.cpython-38.pyc diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5685766 --- /dev/null +++ b/.gitignore @@ -0,0 +1,112 @@ +submission/data +# nvidia-docker-compose +nvidia-docker-compose.yml +# JetBrains IDE +.idea/ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# vscode +.vscode/ diff --git a/featurevis.egg-info/PKG-INFO b/featurevis.egg-info/PKG-INFO deleted file mode 100644 index 8c810b5..0000000 --- a/featurevis.egg-info/PKG-INFO +++ /dev/null @@ -1,16 +0,0 @@ -Metadata-Version: 1.1 -Name: featurevis -Version: 0.2.2 -Summary: Visualize features cells are responsive to via gradient ascent -Home-page: https://github.com/cajal/featurevis -Author: Erick Cobos -Author-email: ecobos@bcm.edu -License: MIT -Description: UNKNOWN -Keywords: feature visualization MEI pytorch -Platform: UNKNOWN -Classifier: Development Status :: 3 - Alpha -Classifier: Intended Audience :: Science/Research -Classifier: Programming Language :: Python :: 3 :: Only -Classifier: License :: OSI Approved :: MIT License -Classifier: Natural Language :: EnglishTopic :: Scientific/Engineering :: Bio-Informatics diff --git a/featurevis.egg-info/SOURCES.txt b/featurevis.egg-info/SOURCES.txt deleted file mode 100644 index 99af5f2..0000000 --- a/featurevis.egg-info/SOURCES.txt +++ /dev/null @@ -1,13 +0,0 @@ -README.md -setup.py -featurevis/__init__.py -featurevis/core.py -featurevis/exceptions.py -featurevis/models.py -featurevis/ops.py -featurevis/utils.py -featurevis.egg-info/PKG-INFO -featurevis.egg-info/SOURCES.txt -featurevis.egg-info/dependency_links.txt -featurevis.egg-info/requires.txt -featurevis.egg-info/top_level.txt \ No newline at end of file diff --git a/featurevis.egg-info/dependency_links.txt b/featurevis.egg-info/dependency_links.txt deleted file mode 100644 index 8b13789..0000000 --- a/featurevis.egg-info/dependency_links.txt +++ /dev/null @@ -1 +0,0 @@ - diff --git a/featurevis.egg-info/requires.txt b/featurevis.egg-info/requires.txt deleted file mode 100644 index 0ef458d..0000000 --- a/featurevis.egg-info/requires.txt +++ /dev/null @@ -1,4 +0,0 @@ -torch>=0.4.0 -scipy -numpy -torchvision diff --git a/featurevis.egg-info/top_level.txt b/featurevis.egg-info/top_level.txt deleted file mode 100644 index 40de682..0000000 --- a/featurevis.egg-info/top_level.txt +++ /dev/null @@ -1 +0,0 @@ -featurevis diff --git a/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb deleted file mode 100644 index 2fd6442..0000000 --- a/featurevis/.ipynb_checkpoints/Untitled-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/featurevis/.ipynb_checkpoints/core-checkpoint.py b/featurevis/.ipynb_checkpoints/core-checkpoint.py deleted file mode 100644 index bf5c92c..0000000 --- a/featurevis/.ipynb_checkpoints/core-checkpoint.py +++ /dev/null @@ -1,260 +0,0 @@ -import warnings - -import torch -from torch import optim - -from featurevis.exceptions import FeatureVisException - - -def gradient_ascent(f, x, transform=None, regularization=None, gradient_f=None, - post_update=None, optim_name='SGD', step_size=0.1, optim_kwargs={}, additional_kwargs={}, - num_iterations=1000, save_iters=None, print_iters=100): - """ Maximize f(x) via gradient ascent. - - Objective: f(transform(x)) - regularization(transform(x)) - Update: x_{t+1} = post_update(x_{t} + step_size * gradient_f(x_{t}.grad)) - - Arguments: - f (function): Real-valued differentiable function to be optimized - x (torch.Tensor): Initial guess of the input to optimize. - transform (function): Differentiable transformation applied to x before sending it - through the model, e.g., an image generator, jittering, scaling, etc. - regularization (function): Differentiable regularization term, e.g., natural - prior, total variation, bilateral filters, etc. - gradient_f (function): Non-differentiable. Receives the gradient of x and outputs - a preconditioned gradient, e.g., blurring, masking, etc. - post_update (function): Non-differentiable. Function applied to x after each - gradient update, e.g., keep the image norm to some value, blurring, etc. - optim_name (string): Optimizer to use: SGD or Adam. - step_size (float): Size of the step size to give every iteration. - optim_kwargs (dict): Dictionary with kwargs for the optimizer - num_iterations (int): Number of gradient ascent steps. - save_iters (None or int): How often to save x. If None, it returns the best x; - otherwise it saves x after each save_iters iterations. - print_iters (int): Print some results every print_iters iterations. - - Returns: - optimal_x (torch.Tensor): x that maximizes the desired function. If save_iters is - not None, this will be a list of tensors. - fevals (list): Function evaluations at each iteration. We also evaluate at x_0 - (the original input) so this will have max_iterations + 1 elements. - reg_terms (list): Value of the regularization term at each iteration. We also - evaluate at x_0 (the original input) so this will have max_iterations + 1 - elements. Empty if regularization is None. - - Note: - transform, regularization, gradient_f and post_update receive one positional - parameter (its input) and the following optional named parameters: - iteration (int): Current iteration (starts at 1). - - The number of optional parameters may increase so we recommend to write functions - that receive **kwargs (or use the varargin decorator below) to make sure they will - still work if we add other optional parameters in the future. - """ - # Basic checks - if x.dtype != torch.float32: - raise ValueError('x must be of torch.float32 dtype') - x = x.detach().clone() # to avoid changing original - x.requires_grad_() - - # Declare optimizer - if optim_name == 'SGD': - optimizer = optim.SGD([x], lr=step_size, **optim_kwargs) - elif optim_name == 'Adam': - optimizer = optim.Adam([x], lr=step_size, **optim_kwargs) - else: - raise ValueError("Expected optim_name to be 'SGD' or 'Adam'") - - # Run gradient ascent - fevals = [] # to store function evaluations - reg_terms = [] # to store regularization function evaluations - saved_xs = [] # to store xs (ignored if save_iters is None) - for i in range(1, num_iterations + 1): - # Zero gradients - if x.grad is not None: - x.grad.zero_() - - # Transform input - transformed_x = x if transform is None else transform(x, iteration=i) - - # f(x) - feval = f(transformed_x) - fevals.append(feval.item()) - - if additional_kwargs: - # Stop optimization when feval reaches target activation - if feval >= additional_kwargs['target_level'] * additional_kwargs['mei_activation']: - break - - # Regularization - if regularization is not None: - reg_term = regularization(transformed_x, iteration=i) - reg_terms.append(reg_term.item()) - else: - reg_term = 0 - - # Compute gradient - (-feval + reg_term).backward() - if x.grad is None: - raise FeatureVisException('Gradient did not reach x.') - - # Precondition gradient - x.grad = x.grad if gradient_f is None else gradient_f(x.grad, iteration=i) - if (torch.abs(x.grad) < 1e-9).all(): - warnings.warn('Gradient for x is all zero') - - # Gradient ascent step (on x) - optimizer.step() - - # Cleanup - if post_update is not None: - with torch.no_grad(): - x[:] = post_update(x, iteration=i) # in place so the optimizer still points to the right object - - # Report results - if i % print_iters == 0: - feval = feval.item() - reg_term = reg_term if regularization is None else reg_term.item() - x_std = x.std().item() - print('Iter {}: f(x) = {:.2f}, reg(x) = {:.2f}, std(x) = {:.2f}'.format(i, - feval, reg_term, x_std)) - - # Save x - if save_iters is not None and i % save_iters == 0: - saved_xs.append(x.detach().clone()) - - # Record f(x) and regularization(x) for the final x - with torch.no_grad(): - transformed_x = x if transform is None else transform(x, iteration=i + 1) - - feval = f(transformed_x) - fevals.append(feval.item()) - - if regularization is not None: - reg_term = regularization(transformed_x, iteration=i + 1) - reg_terms.append(reg_term.item()) - print('Final f(x) = {:.2f}'.format(fevals[-1])) - - # Set opt_x - opt_x = x.detach().clone() if save_iters is None else saved_xs - - return opt_x, fevals, reg_terms - - -def contour_walk(f, f_act, x, mei_act, random_dir=None, target_level=0.85, dev_thre=0, seed=0, transform=None, regularization=None, gradient_f=None, - post_update=None, optim_name='SGD', step_size=0.1, optim_kwargs={}, - num_iterations=1000, save_iters=None, print_iters=100): - # Basic checks - if x.dtype != torch.float32: - raise ValueError('x must be of torch.float32 dtype') - x = x.detach().clone() # to avoid changing original - x.requires_grad_() - - # Declare optimizer - if optim_name == 'SGD': - optimizer = optim.SGD([x], lr=step_size, **optim_kwargs) - elif optim_name == 'Adam': - optimizer = optim.Adam([x], lr=step_size, **optim_kwargs) - else: - raise ValueError("Expected optim_name to be 'SGD' or 'Adam'") - - # Run gradient ascent - fevals = [] # to store function evaluations - reg_terms = [] # to store regularization function evaluations - activations = [] - saved_xs = [x.detach().clone()] # to store xs (ignored if save_iters is None) - - torch.manual_seed(seed) - - for i in range(1, num_iterations + 1): - # keep walking until walks off the equal activation contour with small amount of allowed deviation: - # Zero gradients - if x.grad is not None: - x.grad.zero_() - - # Transform input - transformed_x = x if transform is None else transform(x, iteration=i) - - # f(x) - feval = f(transformed_x) - fevals.append(feval.item()) - - # get image activation - act = f_act(transformed_x).item() - activations.append(act) - - # Regularization - if regularization is not None: - reg_term = regularization(transformed_x, iteration=i) - reg_terms.append(reg_term.item()) - else: - reg_term = 0 - - # Random walk or optimize back to the target activation level - if random_dir is None: # keep optimizing back to target activation level - (-feval + reg_term).backward() - if gradient_f is not None: - x.grad = gradient_f(x.grad, iteration=i) - x.grad = x.grad / torch.norm(x.grad) - - elif (act >= mei_act * (target_level - dev_thre)):# and (act <= mei_act * (target_level + dev_thre)): - direction = torch.randn(x.shape).cuda() - if random_dir == 'random': # random walk - x.grad = direction - - elif random_dir == 'ortho': # walk orthogonal to gradient direction - f_act(transformed_x).backward() - grad_norm = torch.sqrt(torch.sum(x.grad**2)) - walk_direction = direction - (torch.dot(direction.view(-1), x.grad.view(-1)) / grad_norm**2) * x.grad - x.grad = walk_direction - - if gradient_f is not None: - x.grad = gradient_f(x.grad, iteration=i) - x.grad = x.grad / torch.norm(x.grad) - - else: - (-feval + reg_term).backward() - if gradient_f is not None: - x.grad = gradient_f(x.grad, iteration=i) - x.grad = x.grad / torch.norm(x.grad) - - if (torch.abs(x.grad) < 1e-9).all(): - warnings.warn('Gradient for x is all zero') - - # Gradient ascent step (on x) - optimizer.step() - - # Cleanup - if post_update is not None: - with torch.no_grad(): - x[:] = post_update(x, iteration=i) # in place so the optimizer still points to the right object - - # Report results - if i % print_iters == 0: - feval = feval.item() - reg_term = reg_term if regularization is None else reg_term.item() - x_std = x.std().item() - print('Iter {}: f(x) = {:.2f}, reg(x) = {:.2f}, std(x) = {:.2f}'.format(i, - feval, reg_term, x_std)) - - # Save x - if save_iters is not None and i % save_iters == 0: - saved_xs.append(x.detach().clone()) - - - # Record f(x) and regularization(x) for the final x - with torch.no_grad(): - transformed_x = x if transform is None else transform(x, iteration=i + 1) - - feval = f(transformed_x) - fevals.append(feval.item()) - - if regularization is not None: - reg_term = regularization(transformed_x, iteration=i + 1) - reg_terms.append(reg_term.item()) - print('Final f(x) = {:.2f}'.format(fevals[-1])) - - # Set opt_x - opt_x = x.detach().clone() if save_iters is None else saved_xs - - return opt_x, activations, fevals, reg_terms \ No newline at end of file diff --git a/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb b/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb deleted file mode 100644 index e7b5e2c..0000000 --- a/featurevis/.ipynb_checkpoints/high_low tuning-checkpoint.ipynb +++ /dev/null @@ -1,18445 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 133, - "metadata": {}, - "outputs": [], - "source": [ - "import datajoint as dj\n", - "import featurevis\n", - "import numpy as np\n", - "import torch\n", - "from torch import nn\n", - "from featurevis import models\n", - "from featurevis import ops\n", - "from featurevis import utils\n", - "from itertools import product\n", - "\n", - "from staticnet_analyses import base, gabors\n", - "from staticnet_analyses import utils as static_utils\n", - "from staticnet_experiments import models as static_models\n", - "from staticnet_invariance import high_low, zd_deis\n", - "from staticnet_invariance.high_low import * \n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from torch import nn\n", - "from featurevis import utils\n", - "\n", - "torch.pi = torch.acos(torch.zeros(1)).item() * 2 # which is 3.1415927410125732\n", - "\n", - "class CombPlaidGenerator(nn.Module):\n", - "\n", - " def __init__(self, device='cpu', image_size=(36, 64), center=(0., 0.), mask_sigma=5):\n", - " \"\"\"\n", - " Combined Plaid generator class.\n", - " Params:\n", - " device: 'cuda' or None\n", - " image_size (tuple of integers): Image height and width.\n", - " center (tuple of integers): The center position of the pattern.\n", - " edge_theta (float): Orientation of the boundary between the two plaids (in radian).\n", - " theta (float): Orientation of the sinusoid (in radian).\n", - " sigma (float): std deviation of the Gaussian.\n", - " Lambda (float): Sinusoid wavelengh (1/frequency).\n", - " psi (float): Phase of the sinusoid.\n", - " gamma (float): The ratio between sigma in x-dim over sigma in y-dim (acts\n", - " like an aspect ratio of the Gaussian).\n", - "\n", - " Returns:\n", - " 2D torch.tensor: An image with two combined plaids.\n", - " \"\"\"\n", - " \n", - " super().__init__()\n", - " self.device = device\n", - " self.image_size = image_size\n", - " self.center = center\n", - " self.mask_sigma = mask_sigma\n", - " \n", - " def gen_gabor(self, theta, Lambda, sigma, psi, gamma):\n", - " ymax, xmax = self.image_size\n", - " xmax, ymax = (xmax - 1)/2, (ymax - 1)/2\n", - " xmin = -xmax\n", - " ymin = -ymax\n", - " (y, x) = torch.meshgrid(torch.arange(ymin, ymax+1), torch.arange(xmin, xmax+1))\n", - " x = x.to(self.device)\n", - " y = y.to(self.device)\n", - " \n", - " # Clip values in reasonable range\n", - " theta.data.clamp_(0, torch.pi)\n", - " psi.data.clamp_(0, torch.pi*2)\n", - " sigma.data.clamp_(3., min(self.image_size)/2) #min(self.image_size)/7, min(self.image_size)/5) #2)\n", - "\n", - " sigma_x = sigma\n", - " sigma_y = sigma / gamma\n", - " \n", - " # Rotation\n", - " x_theta = (x - self.center[0]) * torch.cos(theta) + (y - self.center[1]) * torch.sin(theta)\n", - " y_theta = -(x - self.center[0]) * torch.sin(theta) + (y - self.center[1]) * torch.cos(theta)\n", - " gb = torch.exp(-.5 * (x_theta ** 2 / sigma_x ** 2 + y_theta ** 2 / sigma_y ** 2)) * torch.cos(2 * torch.pi / Lambda * x_theta + psi)\n", - "\n", - " return gb.view(1, 1, *self.image_size)\n", - " \n", - " def gen_plaid(self, gabor1, gabor2):\n", - " return gabor1 + gabor2\n", - " \n", - " def gen_comb_plaid(self, plaid1, plaid2, edge_center_x, edge_center_y, edge_theta):\n", - "\n", - " edge_theta.data.clamp_(-torch.pi/2, torch.pi/2)\n", - " \n", - " ymax, xmax = self.image_size\n", - " xmax, ymax = (xmax - 1)/2, (ymax - 1)/2\n", - " xmin = -xmax\n", - " ymin = -ymax\n", - " (y, x) = torch.meshgrid(torch.arange(ymin, ymax+1), torch.arange(xmin, xmax+1))\n", - " x = x.to(self.device)\n", - " y = y.to(self.device)\n", - " \n", - " px, py = edge_center_x, edge_center_y\n", - " del_x = torch.tensor([1.], dtype=torch.float32).to(self.device)\n", - " qx, qy = (px + del_x, py - del_x * torch.tan(edge_theta))\n", - "\n", - " mask1 = torch.as_tensor((qx - px) * (y - py) - (qy - py) * (x - px), dtype=torch.float32, device=self.device)\n", - " mask1 = torch.sigmoid(mask1)\n", - " mask2 = torch.ones_like(mask1) - mask1\n", - " \n", - " blur = ops.GaussianBlur(self.mask_sigma)\n", - " blur_mask1 = blur(mask1[None, None])\n", - " blur_mask2 = blur(mask2[None, None])\n", - "\n", - " return plaid1 * blur_mask1 + plaid2 * blur_mask2, blur_mask1, blur_mask2, mask1, mask2\n", - " \n", - " @utils.varargin\n", - " def forward(self, params):\n", - " edge_center_x, edge_center_y, edge_theta, theta1, angle1, Lambda1, sigma1, psi1, gamma1, theta2, angle2, Lambda2, sigma2, psi2, gamma2 = params\n", - " gb1 = self.gen_gabor(theta1, Lambda1, sigma1, psi1, gamma1)\n", - " gb2 = self.gen_gabor(theta1+angle1, Lambda1, sigma1, psi1, gamma1)\n", - " plaid1 = self.gen_plaid(gb1, gb2)\n", - " gb3 = self.gen_gabor(theta2, Lambda2, sigma2, psi2, gamma2)\n", - " gb4 = self.gen_gabor(theta2+angle2, Lambda2, sigma2, psi2, gamma2)\n", - " plaid2 = self.gen_plaid(gb3, gb4)\n", - " image, blur_mask1, blur_mask2, mask1, mask2 = self.gen_comb_plaid(plaid1, plaid2, edge_center_x, edge_center_y, edge_theta)\n", - " \n", - " return image, blur_mask1, blur_mask2, plaid1, plaid2, gb1, gb2, gb3, gb4,#, mask1, mask2\n", - " \n", - "# return image\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def center_and_crop_image(image, x_offset, y_offset, output_size=(32, 32)):\n", - " \"\"\" Center image to the closest integer and crop it\n", - "\n", - " Arguments:\n", - " image (array): Original image\n", - " x_offset (float): How far to the right (in x) is the image center.\n", - " y_offset (float): How far to the bottom (in y) is the image center.\n", - " output_size (tuple): How far to the right is the image center.\n", - "\n", - " Returns:\n", - " Centered image after cropping to the desired output size.\n", - " \"\"\"\n", - " \n", - " if output_size == (64, 64):\n", - " x_offset = x_offset*2\n", - " y_offset = y_offset*2\n", - " top = (image.shape[0] - output_size[0]) / 2 + y_offset\n", - " bottom = (image.shape[0] - output_size[0]) / 2 - y_offset\n", - " left = (image.shape[1] - output_size[1]) / 2 + x_offset\n", - " right = (image.shape[1] - output_size[1]) / 2 - x_offset\n", - " top, bottom, left, right = (int(round(x)) for x in [top, bottom, left, right])\n", - "\n", - " # Pad image\n", - " pad_amount = ((abs(top) if top < 0 else 0, abs(bottom) if bottom < 0 else 0),\n", - " (abs(left) if left < 0 else 0, abs(right) if right < 0 else 0))\n", - " padded = np.pad(image, pad_amount, mode='edge')\n", - " top, bottom, left, right = (np.clip(top, 0, None), np.clip(bottom, 0, None),\n", - " np.clip(left, 0, None), np.clip(right, 0, None))\n", - "\n", - " # Crop\n", - " cropped = padded[top:padded.shape[0] - bottom, left:padded.shape[1] - right]\n", - " if cropped.shape != output_size:\n", - " raise ValueError('Something wrong with the cropping. This may fail for '\n", - " 'images with odd dimensions.')\n", - "\n", - " return cropped\n", - "\n", - "def make_crop_mei(mei, mask_x, mask_y, output_size=(32, 32)):\n", - " top = (mei.shape[0] - output_size[0]) / 2 + mask_y\n", - " bottom = (mei.shape[0] - output_size[0]) / 2 - mask_y\n", - " left = (mei.shape[1] - output_size[1]) / 2 + mask_x\n", - " right = (mei.shape[1] - output_size[1]) / 2 - mask_x\n", - " top, bottom, left, right = (int(round(x)) for x in [top, bottom, left, right])\n", - "\n", - " # Pad image\n", - " pad_amount = ((abs(top) if top < 0 else 0, abs(bottom) if bottom < 0 else 0),\n", - " (abs(left) if left < 0 else 0, abs(right) if right < 0 else 0))\n", - " padded = np.pad(mei, pad_amount, mode='edge')\n", - " top, bottom, left, right = (np.clip(top, 0, None), np.clip(bottom, 0, None),\n", - " np.clip(left, 0, None), np.clip(right, 0, None))\n", - "\n", - " # Crop\n", - " cropped = padded[top:padded.shape[0] - bottom, left:padded.shape[1] - right]\n", - " if cropped.shape != output_size:\n", - " raise ValueError('Something wrong with the cropping. This may fail for images'\n", - " 'with odd dimensions.')\n", - " return cropped\n", - "\n", - "# centered_mei = center_and_crop_image(mei, x_offset, y_offset)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def rotate_mei(mei, mask, mask_x, mask_y, angle, target_std, target_mean):\n", - " nonmask = np.ones(mask.shape) - mask\n", - " background = (mei * nonmask).sum(axis=(-1, -2), keepdims=True) / nonmask.sum()\n", - " h, w = mei.shape\n", - " pad_h, pad_w = int(h/2), int(w/2)\n", - " pad_mei = np.pad(mei, ((pad_h, pad_h), (pad_w, pad_w)), 'constant', constant_values=background)\n", - " center_mei = np.roll(pad_mei, [-int(round(mask_y)), -int(round(mask_x))], axis=[0, 1])\n", - " rotate_mei = rotate(center_mei, angle, reshape=False)\n", - " shift_back_mei = np.roll(rotate_mei, [int(round(mask_y)), int(round(mask_x))], axis=[0, 1])\n", - " crop_mei = shift_back_mei[pad_h:h+pad_h, pad_w:w+pad_w]\n", - " \n", - " # match contrast within mask\n", - " im_mean = (crop_mei * mask).sum(axis=(-1, -2), keepdims=True) / mask.sum()\n", - " im_std = np.sqrt(np.sum(((crop_mei - im_mean) ** 2) * mask, axis=(-1, -2), keepdims=True) / mask.sum())\n", - " unmasked_im = ((crop_mei - im_mean) / im_std) * target_std + target_mean\n", - " masked_im = unmasked_im * mask + (1 - mask) * target_mean\n", - " \n", - " return masked_im" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "annotation = np.load('/src/static-networks/cell_type.pickle', allow_pickle=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 203, - "metadata": {}, - "outputs": [], - "source": [ - "examples = {}\n", - "examples['phase'] = ['106_438', '106_4757', '204_1100', '204_8118', '209_2796']\n", - "examples['texture'] = ['74_5962', '74_5977', '106_643', '106_6192', '204_1004', '204_1108', '88_788']\n", - "examples['corner'] = ['106_3820', '106_189', '166_1943', '204_1259', '204_1366']\n", - "examples['curvature'] = ['74_4890', '46_6214', '46_5701', '74_4470', '74_5651']\n", - "examples['high_low_frequency'] = ['46_879', '46_6369', '74_388', '74_2822', '74_6879', '88_1222', '88_832', '74_5468', '106_6229']\n", - "examples['center_surround'] = ['74_5726', '88_2588', '88_5759', '166_1199', '106_5018']" - ] - }, - { - "cell_type": "code", - "execution_count": 204, - "metadata": {}, - "outputs": [], - "source": [ - "type_key = 'high_low_frequency'\n" - ] - }, - { - "cell_type": "code", - "execution_count": 205, - "metadata": {}, - "outputs": [], - "source": [ - "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", - "[{'group_id': int(key.split('_')[0]), 'neuron_id': int(key.split('_')[1])} for key in examples[type_key]]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" - ] - }, - { - "cell_type": "code", - "execution_count": 199, - "metadata": {}, - "outputs": [], - "source": [ - "dei_examples = ['204_8118', '74_5962', '204_1366', '74_4470', '88_5759']\n", - "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", - "[{'group_id': int(key.split('_')[0]), 'neuron_id': int(key.split('_')[1])} for key in dei_examples]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" - ] - }, - { - "cell_type": "code", - "execution_count": 206, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "9" - ] - }, - "execution_count": 206, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(meis)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "all_images = []\n", - "for key, mask_x, mask_y, mei, optcp, param, act in zip(keys, xs, ys, meis, optcps, params, acts/mei_acts):\n", - " images = [mei[None], optcp[None]]\n", - " optcp_params = (OptimizationParameters & key).fetch1()\n", - " image_size = torch.as_tensor([optcp_params['height'], optcp_params['width']], device='cuda')\n", - " center = torch.as_tensor([mask_x, mask_y], device='cuda')\n", - " generator = CombPlaidGenerator('cuda', image_size, center, optcp_params['mask_sigma'])\n", - " tensor_param = torch.as_tensor(list(param[0]), dtype=torch.float32, device='cuda')\n", - " images.append(torch.stack(generator(tensor_param)).cpu().detach().squeeze().numpy())\n", - " all_images.append(np.concatenate(images, axis=0))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(len(all_images), 11, figsize=(33, len(all_images)*2))\n", - "for images, act, axis in zip(all_images, acts/mei_acts, axes):\n", - " axis[0].set_title('1.0')\n", - " axis[1].set_title('{:.2f}'.format(act))\n", - " for im, ax in zip(images, axis):\n", - " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - "fig.tight_layout()\n", - "fig.savefig('/src/static-networks/my_notebooks/Figures/high_low/texture_cells_combined_plaids.png')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "def get_tuning(key, mask, mask_x, mask_y, param, param_bound_name, param_name1, param_name2=None, bounds=None, n_points=100, add_rotation=False, f_ratio=False):\n", - " \n", - " # Get parameters\n", - " if bounds == None:\n", - " bounds = (CombPlaidSearchRange & key).fetch1()\n", - " if param_bound_name == 'psi':\n", - " values = np.linspace(bounds['lower_{}'.format(param_bound_name)], bounds['upper_{}'.format(param_bound_name)], n_points)\n", - " elif param_bound_name == 'lambda':\n", - " values = 2**np.linspace(1, 5, n_points)\n", - " \n", - " if add_rotation:\n", - " rot_values = np.linspace(-90, 90, n_points)\n", - " \n", - " mask_stats_params = (MaskStatsParameters & key).fetch1()\n", - " optcp_params = (OptimizationParameters & key).fetch1()\n", - "\n", - " # Get predictive model\n", - " model_key = ({'group_id': key['group_id'], 'net_hash': key['net_hash']} if\n", - " optcp_params['use_avg_model'] else key)\n", - " all_keys = (static_models.Model & model_key & 'seed > 1000').fetch('KEY')\n", - " all_models = [(static_models.Model & mk).load_network() for mk in all_keys]\n", - " mean_eyepos = ([0, 0] if (base.Dataset.TrainStats & key).fetch1('norm_eyepos')\n", - " else (base.Dataset.TrainStats & key).fetch1('mean_eyepos'))\n", - " mean_eyepos = torch.tensor(mean_eyepos, dtype=torch.float32,\n", - " device='cuda').unsqueeze(0)\n", - " model = models.Ensemble(all_models, key['readout_key'], eye_pos=mean_eyepos,\n", - " neuron_idx=key['neuron_id'], device='cuda')\n", - "\n", - " # Prepare generator\n", - " mask = torch.as_tensor(mask, dtype=torch.float32, device='cuda')\n", - " image_size = torch.as_tensor([optcp_params['height'], optcp_params['width']], device='cuda')\n", - " center = torch.as_tensor([mask_x, mask_y], device='cuda')\n", - " generator = CombPlaidGenerator('cuda', image_size, center, optcp_params['mask_sigma'])\n", - " transform = ops.ChangeMaskStats(float(mask_stats_params['fixed_mask_std']), float(mask_stats_params['fixed_mask_mean']), mask, fix_bg=True)\n", - " gen = lambda p: transform(generator(p)[0])\n", - "\n", - " param_copy = param.copy()\n", - " images, tunings = [], []\n", - " if f_ratio and param_name2 is not None:\n", - " if not add_rotation:\n", - " for val1, val2 in zip(values, values[::-1]):\n", - " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", - " param_copy[param_name1] = val1\n", - " param_copy[param_name2] = val2\n", - " else:\n", - " param_copy[param_name2] = val1\n", - " param_copy[param_name1] = val2\n", - " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", - " image = gen(tensor_param).cpu().detach().squeeze().numpy()\n", - " images.append(image)\n", - " tensor_image = torch.as_tensor(image[None, None], dtype=torch.float32, device='cuda')\n", - " with torch.no_grad():\n", - " act = model(tensor_image).item()\n", - " tunings.append(act)\n", - " else:\n", - " for rot_val in rot_values:\n", - " for val1, val2 in zip(values, values[::-1]):\n", - " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", - " param_copy[param_name1] = val1\n", - " param_copy[param_name2] = val2\n", - " else:\n", - " param_copy[param_name2] = val1\n", - " param_copy[param_name1] = val2\n", - " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", - " image = gen(tensor_param).cpu().detach().squeeze().numpy()\n", - " image = rotate_mei(image, mask.cpu().detach().squeeze().numpy(), mask_x, mask_y, rot_val, mask_stats_params['fixed_mask_std'], mask_stats_params['fixed_mask_mean'])\n", - " images.append(image)\n", - " tensor_image = torch.as_tensor(image[None, None], dtype=torch.float32, device='cuda')\n", - " with torch.no_grad():\n", - " act = model(tensor_image).item()\n", - " \n", - " tunings.append(act)\n", - " tunings = np.stack(tunings).reshape(n_points, n_points)\n", - " \n", - " else:\n", - " if param_name2 is not None:\n", - " for val1, val2 in product(values, values):\n", - " if param['Lambda1'] <= param['Lambda2']: # always use the low-frequency component as component 1\n", - " param_copy[param_name1] = val1\n", - " param_copy[param_name2] = val2\n", - " else:\n", - " param_copy[param_name2] = val1\n", - " param_copy[param_name1] = val2\n", - " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", - " images.append(gen(tensor_param).cpu().detach().squeeze().numpy())\n", - " with torch.no_grad():\n", - " act = model(gen(tensor_param)).item()\n", - " tunings.append(act)\n", - " tunings = np.stack(tunings).reshape(n_points, n_points)\n", - " else:\n", - " for val in values:\n", - " param_copy[param_name1] = val\n", - " tensor_param = torch.as_tensor(list(param_copy[0]), dtype=torch.float32, device='cuda')\n", - " images.append(gen(tensor_param).cpu().detach().squeeze().numpy())\n", - " with torch.no_grad():\n", - " act = model(gen(tensor_param)).item()\n", - " tunings.append(act)\n", - " return values, images, tunings" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", - "annotation['texture']).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "15" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(keys)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.20981174, 0.22388249, 0.34946156, 0.4266715 , 0.48372184,\n", - " 0.51103968, 0.48757452, 0.42270056, 0.35441452, 0.30187755,\n", - " 0.2664458 , 0.24121719, 0.22685729, 0.22035087, 0.2166823 ,\n", - " 0.21254382, 0.20764571, 0.2019327 , 0.19584462, 0.18990151])" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.array(highsf_acts) / 4.5" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(15, 20)" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.stack(dic['high_low']['highphases']).shape" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(15, 20)" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.stack(dic['curvature']['lowphases']).shape" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'curvature'" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ctype" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20-04-2021:21:50:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:34 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:35 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:35 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:36 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:36 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:37 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:37 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:38 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:38 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:39 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:39 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:40 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:40 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:40 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:40 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:42 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:44 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:44 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:45 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:46 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:47 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:48 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:49 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:50 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:50 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:50 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:51 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:51 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:51 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:52 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:52 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:52 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:52 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:53 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:53 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:53 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:53 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:54 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:55 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:56 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:56 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:57 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:57 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:58 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:58 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:58 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:58 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:58 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:58 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:59 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:59 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:50:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:50:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:50:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:50:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:50:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:50:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:50:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:50:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:50:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:50:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:50:59 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:50:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:50:59 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:50:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:50:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:50:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:50:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:50:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:50:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:50:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:50:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:50:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:00 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:00 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:01 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:01 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:01 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:01 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:01 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:01 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:02 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:02 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:02 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:02 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:02 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:02 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:03 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:03 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:03 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:03 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:03 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:03 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:51:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:51:04 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:51:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:51:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:04 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:04 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:04 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:05 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:05 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:05 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:05 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:05 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:05 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:06 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:06 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:07 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:07 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:08 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:08 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:09 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:09 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:09 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:09 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:09 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:09 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:10 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:10 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:10 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:10 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:10 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:10 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:11 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:11 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:11 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:11 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:11 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:11 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:12 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:12 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:12 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:12 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:12 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:12 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:13 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:13 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:13 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:13 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:13 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:13 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:14 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:14 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:14 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:14 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:14 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:14 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:15 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:15 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:15 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:15 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:15 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:15 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:16 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:16 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:16 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:16 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:16 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:16 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:17 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:17 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:17 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:17 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:17 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:17 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:18 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:18 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:18 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:18 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:18 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:18 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:19 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:19 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:19 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:19 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:19 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:19 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:20 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:20 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:20 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:20 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:20 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:20 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:21 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:21 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:21 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:21 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:21 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:22 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:22 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:22 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:22 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:22 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:23 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:23 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:23 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:23 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:23 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:51:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:51:24 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:51:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:24 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:51:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:24 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:24 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:24 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:25 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:25 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:25 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:26 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:26 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:26 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:26 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:26 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:26 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:27 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:27 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:27 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:27 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:27 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:27 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:28 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:28 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:28 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:28 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:28 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:28 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:29 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:29 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:29 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:29 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:29 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:29 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:30 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:30 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:30 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:31 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:31 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:31 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:32 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:32 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:32 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:33 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:33 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:33 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:33 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:33 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:33 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:34 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:34 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:34 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:35 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:35 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:35 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:35 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:35 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:35 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:36 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:36 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:36 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:36 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:36 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:36 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:37 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:37 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:37 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:37 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:37 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:37 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:38 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:38 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:40 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:41 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:42 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:42 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:43 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:43 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:45 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:45 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:46 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:46 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:47 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:47 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:47 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:47 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:48 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:48 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:48 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:48 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:48 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:48 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:49 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:49 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:49 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:49 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:49 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:49 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:50 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:50 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:50 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:51 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:51:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:51:51 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:51:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:51 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:51:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:51 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:51:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:51:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:51:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:51:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:51:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:51:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:51:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:51:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:51:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:51:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:51:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:51:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:51:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:51:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:51:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:51:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:51:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:51:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:51:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:51:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:51:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:06 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:06 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:06 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:07 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:07 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:07 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:07 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:07 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:07 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:07 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:07 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:08 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:08 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:08 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:08 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:08 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:08 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:08 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:09 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:09 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:09 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:09 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:09 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:09 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:09 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:10 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:11 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:11 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:12 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:12 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:13 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:13 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:14 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:14 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:15 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:15 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:16 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:16 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:17 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:17 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:18 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:18 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:19 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:20 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:21 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:22 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:22 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:23 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:23 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:24 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:24 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:25 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:25 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:26 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:26 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:27 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:28 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:29 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:30 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:30 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:31 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:31 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:32 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:32 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:33 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:33 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:35 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:35 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:36 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:36 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:37 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:52:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:52:37 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:52:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:52:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:38 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:38 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:38 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:39 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:39 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:39 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:40 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:40 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:40 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:41 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:41 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:41 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:41 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:41 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:42 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:42 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:42 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:42 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:42 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:43 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:43 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:43 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:43 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:43 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:43 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:44 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:44 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:44 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:44 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:44 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:44 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:45 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:45 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:45 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:45 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:45 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:45 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:46 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:46 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:46 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:47 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:47 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:48 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:48 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:48 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:49 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:49 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:49 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:49 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:49 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:50 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:50 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:50 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:50 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:50 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:51 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:51 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:51 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:51 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:52 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:52 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:53 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:53 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:53 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:53 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:54 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:54 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:54 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:54 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:55 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:55 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:55 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:56 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:56 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:56 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:57 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:57 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:58 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:58 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:59 INFO data_schemas.py 1340:\t Loading dataset group209-24867-3-18-5 --> /external/cache/static24867-3-18-preproc5.h5\n", - "20-04-2021:21:52:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:52:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:52:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:52:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:52:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group209-24867-3-18-5\n", - "20-04-2021:21:52:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:52:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:52:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:52:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:52:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:52:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:52:59 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:52:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:52:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:52:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:52:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:52:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:52:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:52:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:52:59 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:52:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:52:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:52:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:53:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:53:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:53:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:53:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:53:00 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:53:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:53:00 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:53:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:53:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:53:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:53:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:53:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:53:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:53:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:53:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:53:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:53:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:53:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:53:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:53:00 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:53:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:53:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:53:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:53:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:53:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:37 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "20-04-2021:21:54:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "20-04-2021:21:54:37 INFO configs.py 351:\t Found 4449 active trials\n", - "20-04-2021:21:54:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:37 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "20-04-2021:21:54:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:38 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:38 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:38 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:39 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:39 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:39 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:40 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:40 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:40 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:40 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:41 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:41 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:41 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:41 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:42 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:42 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:42 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:43 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:43 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:43 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:43 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:44 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:44 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:44 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:44 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:45 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:45 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:45 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:45 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:45 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:46 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:46 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:46 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:46 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:46 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "20-04-2021:21:54:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "20-04-2021:21:54:47 INFO configs.py 351:\t Found 4496 active trials\n", - "20-04-2021:21:54:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:47 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "20-04-2021:21:54:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:47 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:47 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:47 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:47 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:47 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:47 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:48 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:48 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:48 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:48 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:48 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:48 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:49 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:49 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:49 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:49 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:49 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:50 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:50 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:50 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:50 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:50 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:51 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:51 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:51 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:51 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:51 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:51 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:52 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:52 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:52 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:52 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:52 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:52 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:53 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:53 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:53 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:53 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:53 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:53 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:53 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:53 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:53 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:53 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:53 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:53 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:53 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:53 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:53 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:53 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:53 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:53 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:53 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:53 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:53 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:53 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:54:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:54:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:54:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:54:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:54:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:54:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:54:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:54:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:54:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:54:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:54:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:54:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:54:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:54:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:54:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:54:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:54:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:54:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:54:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:54:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:54:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:08 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:08 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:55:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:55:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:55:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:55:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:10 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:10 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:10 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:10 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:10 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:11 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:11 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:11 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:11 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:11 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:12 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:12 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:12 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:12 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:12 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:13 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:13 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:13 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:13 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:14 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:14 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:14 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:14 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:15 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:15 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:15 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:15 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:15 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:16 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:16 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:16 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:16 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:16 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:17 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:17 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:17 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:17 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:17 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:18 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:18 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:18 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:18 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:19 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:19 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:19 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:19 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:20 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:20 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:20 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:20 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:20 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:21 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:21 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:21 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:21 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:21 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:22 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:22 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:22 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:22 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:22 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:23 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:23 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:23 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:23 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:23 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:24 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:24 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:24 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:24 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:24 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:25 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:25 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:25 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:25 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:25 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:26 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:26 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:26 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:26 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:27 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:27 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:27 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:27 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:27 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:28 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:28 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:28 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:28 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:28 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:29 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:29 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:29 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:29 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:29 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:30 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:30 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:30 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:30 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:30 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:31 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:31 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:31 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:31 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:31 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:32 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:32 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:32 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:32 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:32 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:33 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:33 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:33 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:33 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:33 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:55:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:21:55:35 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:21:55:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:55:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:21:55:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:55:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:55:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:55:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:55:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:55:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:55:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:55:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:55:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:55:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:55:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:55:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:21:55:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:55:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:55:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:55:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:55:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:55:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "IOPub message rate exceeded.\n", - "The notebook server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--NotebookApp.iopub_msg_rate_limit`.\n", - "\n", - "Current values:\n", - "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", - "NotebookApp.rate_limit_window=3.0 (secs)\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20-04-2021:21:58:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:58:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:19 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:20 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:21 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:21 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:21 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:22 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:22 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:22 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:22 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:23 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:23 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:23 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:23 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:24 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:24 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:24 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:24 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:25 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:26 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:27 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:28 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:28 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:28 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:29 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:29 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:29 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:30 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:30 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:30 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:30 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:31 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:31 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:31 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:31 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:32 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:32 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:32 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:32 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:32 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:32 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:33 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:33 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:34 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:34 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:35 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:35 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:36 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:37 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:37 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:37 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:37 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:38 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:38 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:38 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:38 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:39 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:39 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:39 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:39 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:40 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:40 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:40 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:40 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:41 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:42 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:43 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:43 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:43 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:43 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:43 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:44 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:44 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:44 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:44 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:44 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:44 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:44 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:44 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:44 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:44 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:44 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:44 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:44 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:44 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:44 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:44 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:44 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:44 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:44 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:44 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:44 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:44 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:44 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:44 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:45 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:45 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:45 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:45 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:45 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:45 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:45 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:45 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:45 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:45 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:45 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:45 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:45 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:45 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:45 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:45 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:45 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:45 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:45 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:45 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:45 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:45 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:45 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:45 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:46 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:46 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:46 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:46 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:46 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:46 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:46 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:46 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:46 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:46 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:46 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:46 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:46 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:58:46 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:58:46 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:58:46 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:58:46 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "20-04-2021:21:58:46 INFO configs.py 351:\t Found 4495 active trials\n", - "20-04-2021:21:58:46 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:58:46 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "20-04-2021:21:58:46 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:58:46 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:58:46 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:58:46 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:58:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:58:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:58:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:58:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:58:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:58:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:58:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:58:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "20-04-2021:21:58:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:58:47 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:58:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:54 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:54 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:54 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:54 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:54 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:55 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:55 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:55 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:55 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:55 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:56 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:56 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:56 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:56 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:56 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:57 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:57 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:57 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:57 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:57 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:58 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:58 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:58 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:58 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:58 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:58 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:21:59:59 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:21:59:59 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:21:59:59 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:21:59:59 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:21:59:59 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:21:59:59 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:21:59:59 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:21:59:59 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:21:59:59 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:21:59:59 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:21:59:59 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:21:59:59 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:21:59:59 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:21:59:59 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:21:59:59 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:21:59:59 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:21:59:59 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:21:59:59 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:21:59:59 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:21:59:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:21:59:59 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:21:59:59 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:00 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:00 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:00 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:00 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:00 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:01 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:01 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:01 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:01 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:01 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:02 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:02 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:02 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:02 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:02 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:02 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:03 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:03 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:03 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:03 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:03 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:03 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:04 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:04 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:04 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:04 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:04 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:05 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:05 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:05 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:05 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:05 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:06 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:06 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:06 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:06 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:06 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:07 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:07 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:07 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:07 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:07 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:08 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:08 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:08 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:08 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:08 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:08 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:09 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:09 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:09 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:09 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:09 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:09 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:09 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:09 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:09 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:09 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:09 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:09 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:09 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:09 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:09 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:09 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:09 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:09 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:09 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:09 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:09 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:09 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:10 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:10 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:10 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:10 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:10 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:10 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:11 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:11 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:11 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:11 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:11 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:11 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:11 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:11 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:12 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:12 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:12 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:12 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:12 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:13 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:13 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:13 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:13 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:13 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:14 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:14 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:14 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:14 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:14 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:14 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:15 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:15 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:15 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:15 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:15 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:15 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:15 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:15 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:15 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:15 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:15 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:15 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:15 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:15 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:15 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:15 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:15 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:15 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:15 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:15 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:15 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:15 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:15 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:15 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:15 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:15 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:16 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:16 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:16 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:16 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:16 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:16 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:16 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:16 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:16 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:16 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:16 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:16 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:16 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:16 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:16 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:16 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:16 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:16 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:16 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:16 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:16 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:17 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:17 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:17 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:17 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:17 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:17 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:17 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:17 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:17 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:17 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:17 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:17 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:17 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:17 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:17 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:17 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:17 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:17 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:17 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:17 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:17 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:17 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:18 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:18 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:18 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:18 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:18 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:18 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:18 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:18 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:18 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:19 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:19 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:19 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:19 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:19 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:20 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:20 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:20 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:20 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:20 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:21 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:21 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:21 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:21 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:21 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:21 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:21 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:21 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:21 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:21 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:21 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:21 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:21 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:21 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:21 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:21 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:21 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:21 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:21 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:21 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:22 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:22 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:22 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:22 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:22 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:22 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:23 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:23 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:23 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:23 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:23 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:23 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:23 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:24 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:24 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:24 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:24 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:24 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:24 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:24 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:24 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:24 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:24 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:24 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:24 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:24 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:24 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:24 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:24 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:24 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:24 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:24 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:24 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:24 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:24 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:24 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:24 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:24 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:24 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:25 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:25 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:25 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:25 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:25 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:26 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:26 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:26 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:26 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:26 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:26 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:27 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:27 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:27 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:27 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:27 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:27 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:27 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:27 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:28 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:28 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:28 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:28 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:28 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:29 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:29 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:29 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:29 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:29 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:29 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:29 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:29 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:29 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:30 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:30 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:30 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:30 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:30 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:30 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:30 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:30 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:30 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:31 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:31 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:31 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:31 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:31 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:31 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:31 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:31 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:31 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:31 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:31 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:31 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:31 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:31 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:31 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:31 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:31 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:31 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:31 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:31 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:31 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:32 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:32 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:32 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:32 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:32 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:32 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:32 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:32 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:32 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:32 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:32 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:32 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:32 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:32 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:32 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:32 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:32 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:32 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:32 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:32 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:32 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:32 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:32 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:32 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:32 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:32 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:33 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:33 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:33 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:33 INFO data_schemas.py 1340:\t Loading dataset group166-23964-10-21-0 --> /external/cache/static23964-10-21-preproc0.h5\n", - "20-04-2021:22:00:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:33 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group166-23964-10-21-0\n", - "20-04-2021:22:00:33 INFO configs.py 351:\t Found 4479 active trials\n", - "20-04-2021:22:00:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:33 INFO configs.py 312:\t Number of samples in the loader will be 4479\n", - "20-04-2021:22:00:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:33 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:34 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:34 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:34 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:34 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:34 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:34 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:35 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:35 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:35 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:35 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:35 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:35 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:36 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:36 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:36 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:36 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:36 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:36 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:37 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:37 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:37 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:37 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:37 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:37 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:37 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:37 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:37 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:37 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:37 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:37 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:37 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:37 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:37 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:37 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:37 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:37 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:37 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:37 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:37 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:37 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:37 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:38 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:38 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:38 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:38 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:38 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:38 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:38 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:38 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:38 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:38 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:38 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:38 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:38 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:38 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:38 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:38 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:38 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:38 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:38 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:38 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:38 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:38 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:38 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:38 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:38 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:38 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:39 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:39 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:39 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:39 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:39 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:39 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:39 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:39 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:39 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:39 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:39 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:39 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:39 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:39 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:39 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:39 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:39 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:39 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:39 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:39 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:39 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:39 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:39 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:39 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:39 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:39 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:40 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:40 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:40 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:40 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:40 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:40 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:40 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:40 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:40 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:40 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:40 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:40 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:40 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:40 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:40 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:40 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:40 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:40 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:40 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:40 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:40 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:40 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:40 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:40 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:40 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:40 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:41 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:41 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:41 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:41 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:41 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:41 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:41 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:41 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:41 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:42 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "20-04-2021:22:00:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "20-04-2021:22:00:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "20-04-2021:22:00:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group204-24620-4-20-5\n", - "20-04-2021:22:00:42 INFO configs.py 351:\t Found 4488 active trials\n", - "20-04-2021:22:00:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "20-04-2021:22:00:42 INFO configs.py 312:\t Number of samples in the loader will be 4488\n", - "20-04-2021:22:00:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "20-04-2021:22:00:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "20-04-2021:22:00:42 INFO configs.py 806:\t Setting cuda=False\n", - "20-04-2021:22:00:42 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "20-04-2021:22:00:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "20-04-2021:22:00:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "20-04-2021:22:00:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "20-04-2021:22:00:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "20-04-2021:22:00:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "20-04-2021:22:00:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "20-04-2021:22:00:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "20-04-2021:22:00:42 INFO data_schemas.py 1340:\t Loading dataset group204-24620-4-20-5 --> /external/cache/static24620-4-20-preproc5.h5\n", - "20-04-2021:22:00:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "20-04-2021:22:00:42 INFO configs.py 377:\t Using statistics source all\n", - "20-04-2021:22:00:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "20-04-2021:22:00:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n" - ] - } - ], - "source": [ - "# 1D tunings\n", - "cell_types = ['texture', 'high_low', 'curvature']\n", - "\n", - "dic = dict()\n", - "for ctype in cell_types:\n", - "\n", - " all_fratios, all_highsfs, all_lowsfs, all_highphases, all_lowphases = [], [], [], [], []\n", - " keys, masks, xs, ys, meis, mei_acts, optcps, acts, params = (base.MEIMask * zd_deis.MaskFixedMEI.proj('mei', 'activation') * high_low.OptimalCombPlaid & 'search_range = 3' & \\\n", - " annotation[ctype]).fetch('KEY', 'mask', 'mask_x', 'mask_y', 'mei', 'activation', 'best_image', 'best_activation', 'best_params')\n", - " \n", - " for key, mei_act, mask, mask_x, mask_y, param in zip(keys, mei_acts, masks, xs, ys, params):\n", - " _, _, fratio_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20, False, True)\n", - " if param['Lambda1'].item() < param['Lambda2'].item():\n", - " _, _, highsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', n_points=20)\n", - " _, _, lowsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda2', n_points=20)\n", - " _, _, highphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', n_points=20)\n", - " _, _, lowphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi2', n_points=20)\n", - " else:\n", - " _, _, highsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda2', n_points=20)\n", - " _, _, lowsf_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', n_points=20)\n", - " _, _, highphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi2', n_points=20)\n", - " _, _, lowphase_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', n_points=20)\n", - "\n", - " all_highsfs.append(np.array(highsf_acts) / mei_act)\n", - " all_lowsfs.append(np.array(lowsf_acts) / mei_act)\n", - " all_highphases.append(np.array(highphase_acts) / mei_act)\n", - " all_lowphases.append(np.array(lowphase_acts) / mei_act)\n", - " all_fratios.append(np.array(fratio_acts) / mei_act)\n", - " \n", - " dic[ctype] = dict(highsfs=all_highsfs, lowsfs=all_lowsfs, highphases=all_highphases, lowphases=all_lowphases, fratios=all_fratios)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(np.stack(dic['high_low']['highphases']).mean(1), np.stack(dic['high_low']['lowphases']).mean(1), label='high_low', color='k')\n", - "\n", - "plt.plot([0, 1], [0, 1], color='gray', linestyle='dashed')\n", - "plt.xlabel('Average activation with phase change in high SF component', fontsize=14)\n", - "plt.ylabel('Average activation with phase\\nchange in low SF component', fontsize=14)\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(np.stack(dic['high_low']['highsfs']).mean(1), np.stack(dic['high_low']['lowsfs']).mean(1), label='high_low', color='k')\n", - "plt.plot([0, 1], [0, 1], color='gray', linestyle='dashed')\n", - "plt.xlabel('Average activation with SF change in high SF component', fontsize=14)\n", - "plt.ylabel('Average activation with SF\\nchange in low SF component', fontsize=14)\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [], - "source": [ - "text_mei_acts, text_gabor_acts, text_plaid_acts, text_cp_acts = \\\n", - "(high_low.OptimalGabor * high_low.OptimalPlaid() * \\\n", - "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", - "high_low.Optima & annotation['texture']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')\n", - "\n", - "hl_mei_acts, hl_gabor_acts, hl_plaid_acts, hl_cp_acts = \\\n", - "(zd_deis.MaskFixedMEI * high_low.OptimalPlaid() * \\\n", - "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", - "gabors.GaborTuning & annotation['high_low']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')\n", - "\n", - "curve_mei_acts, curve_gabor_acts, curve_plaid_acts, curve_cp_acts = \\\n", - "(zd_deis.MaskFixedMEI * high_low.OptimalPlaid() * \\\n", - "(high_low.OptimalCombPlaid & 'search_range = 3').proj(dummy='search_range', cp_act='best_activation', cp_image='best_image') * \\\n", - "gabors.GaborTuning & annotation['curvature']).fetch('activation', 'opt_activation', 'best_activation', 'cp_act')" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 131, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(text_gabor_acts, text_plaid_acts, label='texture')\n", - "plt.scatter(hl_gabor_acts, hl_plaid_acts, label='high_low')\n", - "plt.scatter(curve_gabor_acts, curve_plaid_acts, label='curvature')\n", - "plt.legend()\n", - "plt.plot([1, 4], [1, 4])" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 132, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(text_cp_acts, text_plaid_acts, label='texture')\n", - "plt.scatter(hl_cp_acts, hl_plaid_acts, label='high_low')\n", - "plt.scatter(curve_cp_acts, curve_plaid_acts, label='curvature')\n", - "plt.legend()\n", - "plt.plot([1, 4], [1, 4])" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 96, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD4CAYAAAD2FnFTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/ZElEQVR4nO3dd3hUVfrA8e+bRgihJ9QQAiS0UCVgQUFQOoIIKiKKFcW14u7q/tYVY9lV3HUtiwUbWBAQEFERpEZQUXoJNfREeiChpr6/P+6gIQxkBjNpvJ/nuc/M3HvPmfdOknlz7zn3HFFVjDHGmPz8ijsAY4wxJZMlCGOMMW5ZgjDGGOOWJQhjjDFuWYIwxhjjVkBxB1BYwsLCNCoqqrjDMMaYUmX58uUHVTXc3bYykyCioqJYtmxZcYdhjDGliojsPNc2u8RkjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEKbEioqIQESKfYmKiCjuj8KYYlFmhtowZc/OlBR01KjiDgOJjy/uEIwpFnYGYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9zyaYIQkZ4isklEkkTkSTfb7xeRtSKySkQWi0hz1/ooETnpWr9KRN72ZZzGGGPO5rM7qUXEHxgDdAOSgaUiMkNV1+fZbYKqvu3avx/wCtDTtW2rqrbxVXzGGGPOz5dnEB2AJFXdpqqZwESgf94dVDU9z8sKgPowHmOMMV7wZYKoC+zO8zrZte4MIvInEdkKjAYezrOpgYisFJEEEbnKh3EaY4xxo9gbqVV1jKo2Ap4AnnKt3gNEqmpbYCQwQUQq5S8rIsNFZJmILDtw4EDRBW2MMRcBXyaIFKBentcRrnXnMhG4HkBVM1T1kOv5cmAr0Dh/AVUdq6pxqhoXHh5eWHEbY4zBtwliKRAjIg1EJAgYDMzIu4OIxOR52QfY4lof7mrkRkQaAjHANh/GaowxJh+f9WJS1WwReRCYDfgDH6hqoog8CyxT1RnAgyJyLZAFHAaGuYp3Ap4VkSwgF7hfVVN9Fasxxpiz+XTCIFWdCczMt+7pPM8fOUe5qcBUX8ZmjDHm/Iq9kdoYY0zJZAnCGGOMW5YgjDHGuGUJwhhjjFs+baQ2xhsRkRGk7D7zVhmJj/fpe9atXJHkR0f69D2MKa0sQZgSI2V3CqMWjPrtdXx8PKM6d/bpe8bHJ/i0fmNKM7vEZIwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi2fJggR6Skim0QkSUSedLP9fhFZKyKrRGSxiDTPs+1vrnKbRKSHL+M0xhhzNp8lCBHxB8YAvYDmwC15E4DLBFVtqaptgNHAK66yzYHBQCzQE3jTVZ8xxpgi4ssziA5AkqpuU9VMYCLQP+8Oqpqe52UFQF3P+wMTVTVDVbcDSa76jDHGFBFfThhUF9id53UycGn+nUTkT8BIIAjomqfsknxl67opOxwYDhAZGVkoQRtjjHEUeyO1qo5R1UbAE8BTXpYdq6pxqhoXHh7umwCNMeYi5csEkQLUy/M6wrXuXCYC119gWWOMMYXMl5eYlgIxItIA58t9MDAk7w4iEqOqW1wv+wCnn88AJojIK0AdIAb4xYexmkISERFFSsrOCy4fHx9/5usEz+eMrhgUzMjLz7qKaYy5QD5LEKqaLSIPArMBf+ADVU0UkWeBZao6A3hQRK4FsoDDwDBX2UQRmQysB7KBP6lqjq9iNYUnJWUno0ZpwTu6ER8vdO486rfXCQkL6Vw/yuPyCTvHX9D7GmPc8+UZBKo6E5iZb93TeZ4/cp6yLwAv+C46Y4wx51PsjdTGGGNKJksQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLUsQxhhj3LIEYYwxxi1LEMYYY9yyBGGMMcYtSxDGGGPcsgRhjDHGLZ+O5moKT0RkBCm7i3bOpLr16pK8K7lI37PICUi+OSjc7iZSKG93UXympsywBFFKpOxOYdSCUQXvWIjiuxT8xVnqKYwa1fm8u8QnJDBqVOF89hfFZ2rKDLvEZIwxxi1LEMYYY9yyBGGMMcYtSxDGGGPc8mmCEJGeIrJJRJJE5Ek320eKyHoRWSMi80Skfp5tOSKyyrXM8GWcxhhjzuazXkwi4g+MAboBycBSEZmhquvz7LYSiFPVEyIyAhgN3OzadlJV2/gqPmOMMefnyzOIDkCSqm5T1UxgItA/7w6qukBVT7heLgEifBiPMcYYL/jyPoi6wO48r5OBS8+z/93At3leB4vIMiAbeFFVp+cvICLDgeEAkZGRfzReU0b55+RSf2cakTvTqHHgOJXTMvDPySXH34+2QNX529ldrxLbG1QlO8Ca5Yw5rUTcKCciQ4E4IO8dS/VVNUVEGgLzRWStqm7NW05VxwJjAeLi4rTIAjalQrXUk1y2JJmWa/dT/lQ2uQKHqoeQVrkc2QF+BGTn0ghovngXfgqZgX6si63BLx3qsLd2xeIO35hi58sEkQLUy/M6wrXuDCJyLfB3oLOqZpxer6oprsdtIrIQaAtszV/emPwqHs2g6/wdtFm1lxx/YUOzcNa1CGdHVBUyyp35Kx8fn8Bzf7uS+jvTaL7+AC3X7eeSVXvZ0LQ6c69pyKGwkGI6CmOKny8TxFIgRkQa4CSGwcCQvDuISFvgHaCnqu7Ps74qcEJVM0QkDOiI04BtzLkpXLJiDz1mb8U/J5efLovgx471OBYadN5i2YH+bI2uxtboanzXvRGX/pzCFT/t5oG3lrH4ynr8s4jCN6ak8VmCUNVsEXkQmA34Ax+oaqKIPAssU9UZwMtAKPC5azC0XaraD2gGvCMiuTgN6S/m6/1kzBlCMzOZlgj9Dm5me1QVZlzXmMPVyntdT0ZwAN93rs/ydrXpPmcrnb/fxU+h8EPyIVIjqvsgcmNKLo8ShIhcB3yjqrneVK6qM4GZ+dY9nef5teco9yPQ0pv3MheviLQ0Xpw3j5rHYHb3hiy5LAL9g6OvHg8N4osBzdjQNJxu0xJp/sB7TIq/iR1tGxRS1MaUfJ522bgZ2CIio0WkqS8DMsYbsfv38+bMmVTIyuLqNvDT5fX+cHLIa2OzMNq3g6PVKnLbXz6h7TcrCq1uY0o6jxKEqg7l90bicSLyk4gMFxHr6mGKTct9+3h5zhzSgoN5oHdvfqzsm/fZXh7e/99dbG/bgP7//oouHywAtU5zpuzzuA1CVdNFZApQHngUGAD8RUReV9U3fBSfMW613LeP0XPnciAkhMd69OBQSAikCvEJCV7X5UmZ//vPS/wjBN6uBfd8/D3ff/89T0cBrpOVihUrM3Lko16/tzElmadtEP2BO4Bo4COgg6ruF5EQYD1gCcIUmdj9+89ODgAonesP86quBMYXWCZh5w46d74agE+vVmp99RX/WLmSevU7Me7qLs4+CTYRkCl7PD2DuAH4r6p+n3elawyluws/LGPcq5uezj/nz+dgSAiP9uhBakjR3qegIvznuusQVe74/nty/P35uFOnIo3BmKLiaYLYmz85iMhLqvqEqs7zQVzGnKXSqVO8OG8eCjx5zTVFnhxOUxH+3a8fAbm53L1gAfsrVcL7C1vGlHye9mLq5mZdr8IMxJjzCczJ4fkFC6h57BhPde1KSqVKxRqPivByv34sb9CAv3z1FV0PF2s4xvjEeROEiIwQkbVAU9ecDaeX7cCaognRGHhsyRJa7d/Pv668knU1ahR3OABk+/sz6qab2F29OtPWQY3t+wsuZEwpUtAZxATgOuBL1+PppZ2r66sxPtd7yxZ6JyXxUatWLGhQsm5UOxYczBO33spxf7jl/z6jfPrJ4g7JmEJTUBuEquoOEflT/g0iUk1VU30UlzEARKem8uiSJSyrXZtxrVv/tl5VOH44guNHIjiZXoPsrPJwJI5th+oTFJxOSJVfqVh9B4Hljvs8xv2VKzOgBfyw9igDn5/Kp/8agvrbsOGm9CsoQUwA+gLLAeW3Xt/get3QR3EZQ+WsbOIXLCAtOJjnOnUiB38Op8Syb9sVpKa0JDvj9/s0/QNOAu1J3lMZ1dO/1rlUDNtOWORyakX/QFD5NJ/F+kslmPlwL/r952u6jFvI/Lu7+uy9jCkq500QqtrX9ViyzutN2afKu5s3UfP4cR7s1pcNO3uye10fTh0LJ6DcMapHrKJq7fWEVttB+Ur78PPPIWHneK6KHEbWqYocPxJB2r7GHEppwfZ1vdm+qRNhdRKp33wuoVX2+CTkFX3bUXdjCp0+WcSvTeqw8UoblcaUbudNECJyyfm2q6oNTGN8osfq1Qw6cJARDR9n/I9PcOpYOBXDttKg3WTC6q3Ezz/77EKBcKjCLtKq7+NYg1ROBh4lw//4b+e9B4GDKvidCKeiBlEpuwpEQ45k4a+BhRL3tw/3ptbWfVz/4nTefu9+jtSqUij1GlMcCrrE9J/zbFPAzqNNoat9+DC3zFzGlQEz+XFbLypU2U3La1+map1E8o/Dd8r/OAcq7OBAhR3QABJZgKgfoRnVqHyqJsHZFQjIDcIv15+snABSD0VyNMuPtPBNpNVaBUPhx9zJhJ2IpNbRRlQ5VRvhwgf7yw4K4POnB3H/ve8w8LmpfPjaHeQG+P+hz8OY4lLQJaYuRRWIMQD+ublcNeEwHbKWc0Cq0DDuMyKazUH8fh9pXlFSy6fwa6WNpIY4kxSGZlSDbdAmuBcVM6rjh/sv5ajycCKzNpu+eIb0I3WhXjzh/b7mUMUk9oduIzSjGpFHWhF2IvKCE8WR2lWZ8efruCl+Cl0+XMC8e92Oam9MiVfQJaauqjpfRG5wt11Vp/kmLHNxEoI/asyfDj5LzUo7ofH91Iv9fdRUJZd9odvYVWUNJwOPEpRdnvqHW1PzWEPKZ1ciYdd4Ktcv+B6JkMp7aNPzX+xa25cdq14g7b3HaXXNfzgWsZjdVdaxvuZCKp2qQcyhSwnNrHZBR7L+6liWL9vGlZ/9wPa2DdgW1+iC6jGmOBXUF6+z6/E6N0tfH8ZlLjJZWVCRyczcOZTeVabQ+KGPIXQ74EoMFbaxNOJLNoX/gH9uIM32d+LS3QOJOtKG8tne31UtfrnUbz0DuIrcnCBWz3yGcptuoH1yfxofuJyTgWksr/M126uuAPFqnqzfzHqwJwciwxnwr+mUTztxQXUYU5wKusQ0yvV4Z9GEYy5Gx4/DhE+VY9zAC4FPsOTuXPwCKgBwJHgvSdV/4XjQYSpkVCV2Xxeqn6j3h9oJzrSEtn2eZd28R1k77zFiLv2YOk38CDtRn63VlrKrylpoW5GTtKE83p1NZAUHMu2pG7h3xLv0/e83fD5qUCHFbEzR8OhuHhGpLiKvi8gKEVkuIq+JSIET9IpITxHZJCJJIvKkm+0jRWS9a/iOeSJSP8+2YSKyxbV4N4azKTWOHoVx4+DQvmy+pD/Z1yWRHlqBU6RB8/Wsrj2bbMmk2f7OtPv1uj/UNnAuwRVSadvrBarVXcOWJcPYva4ngbnlaHrwSprvuxrKn2QF73GY7V7XvTe6FgvuuJrYhPW0mL+uUOM2xtc8vd1zInAAGAgMcj2fdL4CIuIPjMEZ1K85cIuINM+320ogTlVbAVOA0a6y1YBRwKVAB2CUiFT1MFZTShw5Ah9+CEfTcvlWeqF8zdwWzdjJ9yzlf1D9EPUPt6Z9yvXUOB5V6IkhL//ADGK7vEF41M9sWz6YnauvAyD8RH1YfglBhLKGj9mD9z27fxjckV2x9ejz6kzqFnbgxviQpwmitqo+p6rbXcvzQM0CynQAklR1m6pm4iSZ/nl3UNUFqnr64uwSIML1vAcwR1VTVfUwMAfo6WGsphRIS3POHE6eVD4Le5DLA5Zydx1YIe+yQxZQjRj4pT1RR9rgrx5PfPiH+Pnl0Oyqd6jZ8Ad2rBrIjlWuX9dT5WnL3VSlEZvlK3bzo1f1qr8f0/92Pf7ZOXwANl2pKTU8TRDfichgEfFzLTcBswsoUxfYned1smvdudwNfOtNWde82MtEZNmBAwcKPAhTMpw4AZ98AidPwj/jptHj4FvccudlHLwHsjhJrA4mlpsgI7jIYxO/XJpc+R41Gy1m5+oBJG9wuqgGUI4WDCZcY9kmc9jBQq/qTa1bje9GdKc7wFtvFXrcxvhCQcN9HxWRdOBenHGZMl3LRGB4YQUhIkOBOOBlb8qp6lhVjVPVuPDw8MIKx/hQRgZ8+qlzeeme/vuJ3XsbzR8qz/Ra38EKaM8DhNGkWGMUUZpc8QFhkcvY+stQ2OtMh+KHP824gVrahp2SwC5+8KreZde1YxbAn/8MmzcXfuDGFLLzJghVraiqlVyPfqoa4Fr8VLWgvoUpQL08ryNc684gItcCfwf6qWqGN2VN6ZKdDZMmwZ490P+mdA6Wu4weQ09yvEI4t+t8+BoCKPqzBnfEL5dmnd6hSu1E2Pgkh7ZEO+vxozHXUUNbsF3mksJSLyoV7gYoVw7uvhtyL6z7rDFFxeMxiUWkqoh0EJFOp5cCiiwFYkSkgYgEAYOBGfnqbAu8g5Mc8s62Mhvo7nrPqkB3Cr6kZUowVZg+HbZvh8uGzmJBg0ZMabidG3dfyXC/DTSg5N207+efRWyXNyB0Kxum3Mjx/c5NeIIfTbie6tqYJGZyCM/PBn4F+O9/YfFiePNN3wRuTCHxtJvrPcD3OF/S8a7HZ85XRlWzgQdd+24AJqtqoog8KyL9XLu9DIQCn4vIKhGZ4SqbCjyHk2SWAs/a3BOl28KFkLj1MLVH3MlPjXoRlp7GN1Pr07L2PAIpnrmlPREQeApa/h/+5TJYO2EImcec+zOcy00DCaU265kCFbyodNgw6NEDnnwSduzwSdzGFAZPzyAeAdoDO13jM7UFjhRUSFVnqmpjVW2kqi+41j2tqqcTwbWqWlNV27iWfnnKfqCq0a7lQ28PzJQca9bA93u/IuCRWPbW+Jih269gzZtZ7G33ITn+QcUdXsHKHaTF4M/IOl6BdZMGk5vt9KryJ4gW3OJcFmsJRzOOelafCIwd6zzee6/1ajIllqcJ4pSqngIQkXKquhGKuSXRlApJKalMl9tgSD+qBYfx5yOTGPfxUjbG3saOBiXvstK5VKyzh6Y3TONocj02fdn/t+/0clSkBbdAIExOnExObo5nFUZGwujRMHeuczOIMSWQpwkiWUSqANOBOSLyJbDTV0GZsmHZ8S/4tEpzNHYil2c+zXBdyogvx5AZVIHvuv+7uMPzWnizDTToOpf961qS/NPlv62vSG3YCMlHk5m7fa7nFd53H3TqBCNHwq+/+iBiY/4YjxKEqg5Q1SOq+gzwD+B94HofxmVKscNs5zMdwDehNyDHanNT2lK6B8bTdu3nNNixgHnX/IvjFQoedbUkqnflYsKarWfb3G4c2VH/9w0HoH2d9ixJXsKGgxs8q8zPD95/HzIz4f777VKTKXG86cV0iYg8DLQCkl13Rxvzm5NZJ6EzvElzknLnwJwXuSntF5pVbUPwycN0/+5xkut2YHm7QruFpsiJQJP+X1K+Wirrp9xIRvrv82J3b9Sd2qG1+XLjlxw+edizCqOj4bnn4KuvYOJEH0VtzIXxtBfT08B4oDoQBnwoIk/5MjBTeqgqMzbNIPbNWOgC4an9yX19I50DnqBpY2cqz2vm/52QEwf5us/bqHj8f0mJFFAug9ibJ5GTGcT6KTeSm+NMThTgF8CNzW8EYOqGqeSqh/c5PPoodOgADz8MNiKAKUE8/Uu9FWivqqNcQ4BfBtzmu7BMaZGUmkTfz/rSf2J/ygeWh/HN2TdmIjE1I+jsmk2kbsovxC17m186PMTe2m2LN+BCUiH8AE36f0n67ki2fdf9t/VVy1elT+M+pBxNYfGuxZ5V5u8PH3wA6enw0EM+itgY73maIH6FM25xLYfd2XxRO555nKfmP0Xsm7Es2rmIV7q/wqz+q2D7HCpXhgEDnMsxkptDn29GcLRibRZ0eba4wy5UNWITqXvpT6T8cikc+H0cypY1WhIbHkvCzgT2HN3jWWWxsfDUU86t5jNmFLy/MUWgoClH3wAUSAMSRWSO63U34Bffh1d6RUREkZJSuB294uPjPdqvYsXKjBz5aKG+92mqyrQN03hs9mPsTt/N0FZDGX3taMKCa9O1K0AVbr4Zypd39m+/9E3q7FnB54MmkVHO+5nfSrqG184lbVd9jm36gLR946lcMw2APjF92JW2iy82fsHwdsMJ8PNgRNonnoDJk2HECOjcGSpX9nH0xpxfQb+1y1yPy4Ev8qxf6JNoypCUlJ2MGlV4vVLi44XOnUd5tG9CgmeJxFsbD27koW8fYu62ubSq2YpPb/iUq+pfBcAjjzijR8A91Kw5AYCKR3/lmvl/J6lRdxJd1+bLGr+AHJoPmsIvb97B1OcHcser4/Dzz6V8YHn6NenHp2s/ZcGOBXRr2K3gyoKCnF5Nl1/uJIu33/b9ARhzHgUN1jf+9AJ8hpMolgMTXOvMReBoxlH+OuevtHyrJUtTlvJGrzdYPnz5b8nhs8/g9dedJOH8mjh6zB6Jf04mM3uPca43lVHlq6VC4/vYvS6SheOu/m19dLVo2tRqw0+7f/L8UlOHDvDYY/DOO874JMYUI097MV0NbMGZIe5NYLMHg/WZMuCztZ/RdExTXv7xZW5vdTubH9rMgx0e/O2SSWIi3HMPXHklvJxnsPaGW+fQInESi676P1KrRRdT9EWo5kTa9FrBok+vYtvyhr+t7t6wOyGBIXy1+SvPezU9+yw0bOgMw3HiRMH7G+MjnjZS/wforqqdVbUTzoxv//VdWKa47T++H+6AIdOGUDu0NkvuXsL7/d+nRp4b3NLT4YYboGJF59J5oNOjlYCsk/T9ZgSHqsXwQ8e/Fs8BFINeD31LWORBvvjnAI6lOqP3lQ8sT6/oXuw5toefk3/2rKKQEHj3XUhKgmee8V3AxhTA0wQRqKqbTr9Q1c1AoG9CMsUpMyeTOdvm8M7yd6AGvNP3HX6+52cujbj0jP1U4c47YetWJznUrv37tqsW/ZNqh7fydd+3yQ4oGfM7FIWg8lkMevpzTh4tz/QXB6C5zmW15uHNaVytMQt2LIAqHlbWtatzavaf/8CyZQXvb4wPeJoglovIeyJytWt5l98bsE0ZsengJt5c+iY/7v6R1jVbwxswvN1w/P38z9r3lVdg2jR48UVnOKHTmgJX/vASq1sNZXuDrkUXfAlRs+F+ej44i61Lo/lx0hUAiAi9Y3ojItDX6QnmkZdfhpo1ncmFsrJ8GLUx7nmaIO4H1gMPu5b1wAhfBWWK1tGMo0xaN4mJiRMJ8g/izjZ30q9JPzjpfv/vv3c62QwcCI8/nmeDKm8BmUGhfNf9P0UReonU7rplNOu0nvnvdyVlYx0AKgdXpmtUV4iGaRumeVZRlSrOpEJr1jgjvxpTxApMECLiD6xW1VdU9QbX8t8804OaUizxQCJvLXuLpMNJXNvgWu5rdx+RlSPPuf+ePXDTTdCokXPz7xmdk8aP52pgzrUvldrB+AqDCFz35xmEVj/G1OcGkXG8HADt67aHvTDyu5GcyPKw8fn66+HGG52G640bfRe0MW4UmCBUNQfYJCLn/tYwpc7JrJNM2zCNKeunULV8Ve5rdx8dIzu6vZx0WlaWkxyOHnUuL1XKe9/bwYPw5z+zGFh5yd0+j7+kK1/xFAOfmsqRvVX45tU+qIKf+MFM2JW2ixcXv+h5ZW+8ARUq2DzWpsh5eompKs6d1PNEZMbpxZeBGd9JSU/hneXvsG7/Oq6ufzV3t72bsJCwAss98YRzM9x77zkjQ5zhr3+FtDTuh1I/GF9hiWy5i87DFrJ2bivWfNfaWbkLbm15K6N/GM3W1K2eVVSzJrz6Kvz4o81jbYqUp3/J/wD6As/idHk9vZhSRFVZ9usyPlzlzGB2d9u76RzV2fnPtgCTJsF//+uMJXfLLfk2JiQ4s6I9/jiJPoi7NLvq1kXUb7WDb17tw6Hd1QEY3W00gf6BPDb7Mc8ruu026N7dmcd6p83VZYpGQWMxBeM0UEcDa4H3VTXb08pFpCfwGuAPvKeqL+bb3gl4FWeOicGqOiXPthzXewLsyjtftfFeTm4OX2/5mlV7VxFdNZoBzQYQEhjiUdmVK50urR07wr/zTwSXkeFMdhMVBU8/DS+9VOixlwQJCQsL3OecY2WFvAvZq/nfA1cAgdStVBeugK+6f4U0FucWVA90rFmTxeB83jNnlum7003JUNBYTOOBLGAR0AtoDjziScWuxu0xOAP7JQNLRWSGqq7Ps9su4A7gz26qOKmqbTx5L3N+p7JPMTlxMtuPbKdTZCeujrra6XLpgf37nXbSsDCYOtUZLugMo0c7jafffOPc4FVGda4fdd7tCTsTGHV6fHM3NtZ/hUmTXgD+hY46SiY5tNK3yB6SyzoeILjAP0WQ+HhnTJOHH4ZPPnHOKozxoYKuLTRX1aGq+g4wCLjKi7o7AEmqus01+9xEoH/eHVR1h6quAazlzUeOnDrCBys/YGfaTvo36U+XBl08Tg4QyKBBTpKYPt25FH6GxERnNrSbb4bevQs58rKladMfaN/+C+Bxvt0STRD+vE4vtsphXmOJ5xU98IAzmN+jj8K+fb4K1xig4ATx29053lxacqkL7M7zOtm1zlPBIrJMRJaIyPXudhCR4a59lh2wmbjOknoylXGrxpGekc7QlkNpU6uNlzW8zqJFTnfWSy7JtyknB+66yxmS+o03Cinisq1bt7eANQybPoC9x0LpTiP6amNeYBH7Oe5ZJf7+Ti+BY8ecMwljfKigBNFaRNJdy1Gg1ennIpLu49jqq2ocMAR4VUQa5d9BVceqapyqxoWHh/s4nNLl4ImDjFs1jsycTIa1HkaDqg28Kr9sRhxwP08+6aZRGpxeNb/84iQH++w9EhiYCQzmWGYQt38xgFwV/k03TpLNKBZ4XlHz5vCPfzhjnHz5pc/iNaag4b79VbWSa6moqgF5nhc0+0sKUC/P6wi8mIVOVVNcj9tw5p8oG3NVFoUQGLdqHLmay7DWw6hdsXbBZfLYtrwh377eC/ia5593s8OWLc7sZ/37O5eXjBc28GrPWczZ1oh//3gFTQhjBHGMZQWJ7Pe8mr/+FVq1ci45HTnis2jNxc2XHdaXAjEi0kBEgoDBgEf3TohIVREp53oeBnTEGd7DFOAUR6C1M/7PHW3uoGZo/oaD89u3tSaTnr6Z8PoHgCH4579vLjfXuWErONjpk289abx27yXLGdQ8kb/P78ovKXUZRWcqUY4/M8fzSk5PLrR3r5MsjPEBnyUIV5vFg8BsYAMwWVUTReRZEekHICLtRSQZuBF4R0ROd6NvBiwTkdXAAuDFfL2fjBuZHGcNH4MfDG051KOb3/JKP1CJT5+8lXIhGQx5cQJw9Oyd3noLFi1yboqoU6dwAr/IiMDYvl9Rp+JRbpk6kMCMqjxNJ2ZJErNI8ryiuDgYOdIZGnz+fN8FbC5aPr3lVVVnqmpjVW2kqi+41j2tqjNcz5eqaoSqVlDV6qoa61r/o6q2VNXWrsf3fRlnWZBNBmv5hAzSYS1enzlkHC/HhCeHkHGiHEP+9SmVwt00MW3b5txO3aMHDBtWSJFfnKqWP8WEG6ay40gVRnzThwe0A9Fajcf5jmxvOvXFx0NMjNNhIN3XzYLmYmNjIpQBSi4bmMox9tGcm8DL74nsTH8mj7qJ/TtqcNMzk6kV7ab7ZHa20+8+IADGjrVLS4WgY+Runum8kAlrWzFx9SWM5lrWywHeY4XnlYSEwLhxsGsX/OUvPovVXJwsQZQB25hLqmwhml5UJ8arsrk5fkx9bhDbljei31++pFH7c4wP9K9/OWMBvfUWRNq4jYXl/65aROf6O/jTzD40P9SRzlqfp1lAGqc8r+SKK5xx18eOhdmzfResuehYgijl9rKSZPmJOtqeurT3qqzmCl++1J+Ni5vR86GZtOm52v2OP//sXMq49dZz9Hk1F8rfT/nkhmkEB2QzaPLNvJDVh4Oc4J8s8q6i556Dpk2dDgTWq8kUEksQpVg6yWzma6poQ6Lp6VVZVZj5Wm/WzGlN17vncekNv7jf8dgxGDoU6taF//2vEKI2+UVUSuezgVNI3F+D/824n2G04VV+ZjuHPa8kOBjGj3cm7Bg50nfBmouKJYhSKosTrGcKQVSkOYMQL36UqjD7zR4sm9Gejrcs5spbz/Pf6mOPORNPf/yxM8OZ8YlujbbxfNf5TFzXkqgVIwnAjyeZ510lHTo4o71++CF8/bVvAjUXFUsQpZCibGQ6mRyjOTcSSHnPy+YK37zah5+nXM6lA5dwzb1zz9ne3B+cYR2eeOLMiaeNTzx55WL6N9nI898M4eYjvZgsifx4xmg1Hnj6aWjRAoYPh9RU3wRqLhqWIEqh3SwmVbbQiO5U8mJ4q9wc4cvR/Vk+oz0dhyyix59mnTM5VNl7hA/AGYTpXMNYm0LlJ8r467+gQZUjfPPRO9TKrcRjzCYX9byScuWcS00HDthYTeYPswRRyqSTzHYWEK6x1PGiUTon249pLwxk9ew2XH3nfK65Z945k4N/ZjY3PvO588sxebKbMb6Nr1QOzmDazZM4dqwaFRc9wy+SwkTWeVfJJZfA3/8On37qzA1rzAUqeBB6U2LkkMkGplGOSjSmL4Jn9yKcOlaOz5+5iW3LG3Htfd/RcfCP592/5n2jqbsjiwHA9Ohor+OMj3/G6zKneTIxT1nXosZ+Puj3JYOnPUL11mN5svJcBtAUf/B4qPZA4Ceg/sCBtAT2FmJ89evWZUdyciHWaEoqSxClyFZmc4rDtOYOAgj2qEza/kpMePJWDu4Ko/8TX5y7K6tL7Px13Lgjix8vi2D6kmR01CivYpT4eEZ1vtqrMqfFJ8SfMTFPws4dF1RPWXBzi0QSD9TguS/e5tCdV/OK/kQOePfzOHAAxo5lT1QUDBlSaDc3il1yvGjYJabSognskRXUoyNVqO9RkT1bavHeA/eStr8yt770SYHJoWbSXvq/PIMfKsHca70bHtwUvmeuXsiNFcJgwwCe1x8h1MsKwsOhWzdISoKlS30SoynbLEGUAsfYB/0gVGsRRRePyqybH8uHD9+Fn38ud73xAQ3bbT/v/hUOH+eWpyZyKjSYQbGQ62+/GsXNT5Rx10+n5eqRnNJc6FLN+0rat4foaJgzBw4eLPwgTZlml5hKgTn8BcpBUwbgR/7xt8+kuX6Q9G+mLryRei12ceMzk6lY/dh5y/hn5XDTM5OpcPg4H75+J3snvluY4V8khPiEBM/29PoSTS34+Q64/D3k7Xdg3+8tCn4SSK5mnbuoU5q1wM4xY7icPNNE/gEiQt269UlO3lEItZmSyhJEKdCN0az5/GMqDK5x3v0yj1dg/ZRBkNyA9gN+pseI7/APzDl/5ar0fm0m9dfsYspTN/BrExvC+8IonesXPMJtAuMZ1dmL2eNcdqXn8OHJqQT0asKjmz+nQqAzA3B8QheP6pt34HtuXj+KuZG3Mr/BPV6/f17xCQsZNeoZ4uNtwMayzq4jlAKh1IJN598nNakRy94awdHkCGh6G70f/rbg5ABc9eki2n2zgu9vvZJ117QspIhNYYss5w8Le5IdlcAHx38lM8e7P90N4Z1YWasnV+76jHppa30UpSlrLEGUcrnZASTN6sHaT28jMOQEbe95D2p94lHZNrNWcc37C1jdrRXz7+7q40jNH7asIRXTo0i96mkmb2hMTq53/8F/2+ghjgTX4oaN/6Jc9nEfBWnKEksQpdjx/TVY8e69pPx8OXXa/8wl944ltKabuRzciP4liX4vz2BrXENm/KWfze9QGuT603fHcAjbxNZGn/PFxmZQQJtUXpkBIXzR9G9UPrWP3kmv+S5OU2ZYgiiFNNeP3T9cwfKxw8k8XoEWQz4lpve3+LuuSxckcs1Obho1mX2NajIp/iZyAj3/kjHFK+bQZTRIvYTAa54m8Wgg8DG56nly3125BQn1b6f1vjm03mtzR5jz82mCEJGeIrJJRJJE5Ek32zuJyAoRyRaRQfm2DRORLa7F5rd0Oba3Jiveu4dtc7tTLTqJuPvfonrMFo/LRyTu5tYnJ5BWozKfvHgrmSHlfBitKWyC0D1pBFlBaURe92fgFqZvbEquF8M1fV9/KDsqt6LPllepfsLLwQDNRcVnCUJE/IExQC+gOXCLiDTPt9su4A5gQr6y1YBRwKVAB2CUiFT1VaylQzm2z+/KineHk5FeieaDJhN780SCQj2/llxnYwpDn/iUY9VC+eg/t3O8mrd3XpmSoNbxaNru6U1ys4+g2nDW7q/Jl14kCRV/pjV7imy/IAZteA7/3EzfBmxKLV+eQXQAklR1m6pmAhNxjSB9mqruUNU1cNYs7T2AOaqaqqqHgTng5Yw4ZciuXQAr2bWoEzVarqX9A2MIj13vVbNBvXW7ue0vn3CyUnnGv3I7R8Mq+ipcUwS6br+LgNxA6PkuXaK2sWZ/Laaub062hw3X6eXCmd7kCWof20K3bWN9HK0prXyZIOrCGYPZJ7vW+bpsmZGRATNnOvO/QAgtb/2YptdPJzDkpFf1NPolidv+8jEnKocw7pVhpNeo7JN4TdEJzaxG5x13QGOoeclEujdKYv3BGkxY24qMbM/alDaHXcGSugO5LGUqTQ7+4NuATalUqhupRWS4iCwTkWUHDhwo7nAKVVISvPWWM4ROhw4ALagWvdXrepovTGTI3z8jtW41Pnj9TtJqVSnsUE0xuTT5BjgAs2L+R1zkVq5vsoEdR6rw0ZrWHM8M9KiOOQ2Hsyc0hv6bRlMpo2z9DZk/zpcJIgWol+d1hGtdoZVV1bGqGqeqceHh4RccaEly8iRMn+4M5R8YCHfdBb16AZx/uIyzqNLxsx+48dkppDSty7hX77A2hzLGXwNgJhwpv4cfIifSutY+bo5dx/7jFfhwVVsOnSh4psEcvyA+b/Y0/prFDRueR7TgmyvNxcOXCWIpECMiDUQkCBgMzPCw7Gygu4hUdTVOd3etK9PWr4cxY2DtWrjqKrjvPqhXr+By+QXlQv/RM+g2di7rOzXn45dv41SoZ8ODm1JmO8Tuu5ofIidwOHgPTcIOcVurNZzICuS9lZew40iVAqtIDYngm5jHiEpbQ+edH/k+ZlNq+GwsJlXNFpEHcb7Y/YEPVDVRRJ4FlqnqDBFpD3wBVAWuE5F4VY1V1VQReQ4nyQA8q6o+nWA3KiKCnSmenuB4xvOJc0KB3kBzatWCoUOhVq0Le89qR48ydzW0TVvFwmGdSbi9M+pnN8GVZd23PsDm6kuYHT2GweueJ7JyGvdcspzP1rXk4zWt6BOzhUtq7zlvHWtqdqPB4RV03vkxyZViSarWoYiiNyWZTwfrU9WZwMx8657O83wpzuUjd2U/AGda5KKwMyXF68lxzseTiXNUYc2+mszaGk1Wjj85Opd77rkW/wu8b63d1q38/YsvKHcSpvxjIOu6triwikypUikjnE47b2deo7FsqfYzMamXUq38Ke5uu4Ip62P5anMT9h2vQPeGW/H3O3df2Jkxj1D72BZu2PACY9u9w5HgC/wvxZQZpbqRujQ7mhHEZ+taMn1TM8JDTnB/3DJg8QUlB/+cHO6aP5+XP/mEtJAQ2rfDksNF5vLdg6h+vB4zG79Glt8pAIIDchjSci2X1d3NLykRjFvVhrRT574xMss/mMmx8fhpDjcljiLA7o+46FmCKAbrD4Tz1rL2bD9ShZ6NtnBHm5WEhZy4oLoa7NvHm++/z+2LFjG7TRtG3HMPGyoUcsCmxPPXQPpuHsmR8ntY2GDcb+v9ROkRvZVBzRPZf6ICY1e0Y2vque85TS1fly+a/o06xzbTM+mNIojclGQ2H0QRysj259ukGFbvq0WdiukMaLqBMC/vaTgtICeHwT/8wLCEBI4FB/P0jTfyffP8N6qbi0nUkTa0/bUPP0V8Tot911D7WMxv22LDD1CzwjE+Xx/LJ2tbcWW9XVwdtcPtJadNYR1ZVG8IV+2eQHKlWFbVumjvUb3oWYIoIrvSKvHFxmaknQqmU+QOOtXfed7rwefTbutWHp41i/oHDzI/NpbXevcmLSSkkCM2pVG3rfexufqPfNX0Ze5Z/hZ++vs1y7CQk9zTdgXfJsWweHd9th6uxg3NNrg9e13Q4C7qHt1Any3/ZW9oNHtDo4vyMEwJYZeYfEwVFu+KZNyqtghwZ5uVdGng/j+3gtRNTSV+8mT+88knBOTk8OQtt/DsoEGWHMxvymdXpNeWh9hTcQtLIqaetT3QP5d+TTZxU/N1HDkVzDvL27H01zpovl/HXPFnarN/cDKgEjcljiI462gRHYEpSSxB+NCJrAA+W9eSedsb0iz8APe1W0a9yule11Px6K+8CYwfM4YOSUm816ULdz7wAEsaNy78oE2p1/zA1TQ+eDkLG3zI4WD33VubhR9kRNxS6ldOY+aWxny2riXpGUFn7HM8qCqTmz9D5Yx93LDxn3YT3UXIEoTPXM47y+PYdrgqvaM3M6jZesoFePcHVvnITnp++wgPvx7NPcBXl1zCrQ89xCedOpEZYFcHjXuC0Hvzo4gK3zR5BcX92WrFcpnc2nINPRttYfuRKry5tAMr9tQ+42wiuXIssxo9SOPUJXTdXmS9zk0JYd8yPvDx6lbA3/GTbO5qu4I6Fb0bJqPmvjV0/GE0LdZNREVY2/JWBq4eT70+fXwTsClzKmfU4Jpt9/Jt49dZVWsWbff2crufCFwakUJM9VRmbGrCV5ubkLg/nL6NN1O1vNNddmmd/tQ8vo2rdk9gf4UG2NfGxcPOIHygfd1fgUnc1265x8nBPzeTQSRy28fdGfF2a5ps+pIllz7Ca49sZ/r149jm25BNGdQ+pT+RR1qxrub8c55FnFat/EmGtV5Fn5jNJB+txFvL2vNzSl3nbEKEb6MfYkflVvTb/DJxHg+pZko7+1fAB5qGHQQeIjhgQYH71jqWRNu9M2m5bx4hpJN2sB7zujzP0vYPcKr8RT5HkvlDBD9uXvcswdmhCAUPtyICcXV+JabaIb7e3JhZSTEk7q9BvyabCAs5weTm8dy7cgTTT03is6PPFsERmOJmCaIYlM9Kp8X+eVyy91tqH9tCtgSyMexKRh6oS8dHxqF+Nke0KRwhWd7P/VE5OIMhLdf+NgzM28viuCpyJx0jhYmxz3Pb8hEMnnQ9T/kgXlOyWIIoIqI5NDi8krZ7v6XZwUUEaBZ7QmOYGf0wa2tcw8nASsxJWMgVlhxMCSACrWvto1G1VGYnRbNwZwPWHajBdY0r8R0D+CJlMuMAcnPBz65Ul1WWIHysysk9tNk3izZ7Z1MlYx8nAyqyvE5fVtbsxd6KMQVXYEwxCg3KYmDzDbQ6tI9vtjTmw1VtgT/zRecrGJzwKPztb/DSS8UdpvERSxC+kJXFrcCw1SNpcGQlirC1ahxzGt7HprCOZPsFFVhFiSDOqLTeik/o4oNgygj5Y59PfMLZP4+C6qsYHMbISz+/4PcEiKmeygNVlrJgexRLUtpx+/I4BvM9Y0ePRqKiYMSIP1S/KZksQRQWVdizB1asgHXr+ARIPbWP+VF3sapmD9KDaxR3hN5TGDWqs1dF4hMS6Fx/2AW9XcL48RdUrlRR6DzsAj+fnTvoXD8q37rxBX7ehfW5Bvnn0CN6K0tSviU0dDjvHZvI37vcR9SDDzozW/XtWyjvY0oOSxB/VEaGMwXc8uWwdy8EBEBsLJ1Xr6Zrh49R8fz6rHD+SYYSEhZ6XFf8Bfznb4xnfuXee+G557oSNeNbuHoN3HwzJCRAXFxxB2cKkSWIC/Xrr05SWLsWsrKgZk3o3RtatoTgYL5fvZouXiQHAIVzTjIUnxB/1n+P55KwM4FRnb37z//M90q44LLm4uC0Sy+G0FD4+mu47DLo0wcWL4YYa1srKyxBeCM315k4eskSSElxzhZatIB27aBuXafrR4kgf/hL/nR5SxamQLVqwaxZzkTq117rJIkLmUzdlDiWIDyRkQErVzqJIS0NqlWDnj2hdWsIDi7u6NzQC24HgN+vdSdQ8PXts8teBO0I5mxNm8Ls2dClC3TrBt9/DzVKYbubOYNPE4SI9AReA/yB91T1xXzbywEfAe2AQ8DNqrpDRKKADcAm165LVPV+X8bqVno6/PyzcykpIwMiI53E0Lix9f02Jr9LLoFvvoHu3aFHD1iwAKpUKe6ozB/gswQhIv7AGKAbkAwsFZEZqro+z253A4dVNVpEBgMvATe7tm1V1Ta+iu+80tKc0+QVK5zeSc2bw+WXO5eRjDHnduWVMG0a9Ovn9GqaPRsq2By4pZUvzyA6AEmqug1ARCYC/YG8CaI/8Izr+RTgfyLFeCE/PR0WLXIuJ6lC27bQsSNUtTGRjPFYz54wYYLTs6lvX/jqK6cx25Q6vkwQdYHdeV4nA5eeax9VzRaRNKC6a1sDEVkJpANPqeqi/G8gIsOB4QCRkZEXHmlyMm8AvP66kxjatHEa3Oz02JgLM2gQfPQR3H67kzBmzoRKlYo7KuOlktpIvQeIVNVDItIOmC4isap6xnRsqjoWGAsQFxd3YRM8b9kCLVpwHziNzpYYjCkct94KQUEwZIjTLjFrlv1tlTK+bGlNAfL2dYtwrXO7j4gEAJWBQ6qaoaqHAFR1ObAV8M38mtHR8OyzxABcd539AhtTmG68EaZMcdrzrrkGDh0q7oiMF3yZIJYCMSLSQESCgMHAjHz7zABO96McBMxXVRWRcFcjNyLSEIgBH82ZIwJPPMFOn1RujKF/f5g+HRITnW6we9zPk21KHp8lCFXNBh4EZuN0WZ2sqoki8qyI9HPt9j5QXUSSgJHAk671nYA1IrIKp/H6flVN9VWsxhgf693baazetg2uuAI2bSq4jCl2Pm2DUNWZwMx8657O8/wUcKObclOBqb6MzRhTxLp1g4ULnSE5rrjCGaLj8suLOypzHna3lzGm6MTFwY8/OqMRdO0KkyYVd0TmPCxBGGOKVqNGTpKIi4PBg+Ef/3DGOTMljiUIY0zRCw+HuXPhrrvg+edh4EDnRlVToliCMMYUj3Ll4L334LXXnAbsdu2cUQxMiWEJwhhTfETg4YedxuuTJ51G67feckY0MMXOEoQxxit5Zz4UkcJZrrqKsJQUZmZkwAMPMMPPj9rn2T8qIqJYP4PToiIiCu8z+AOLrz6PkjrUhjGmhDo982F8Qjw6alQhV67w88/0mzePfoGBzv0TsbFnTcYlJWRK3Z0pKYX/GVwAX30edgZhjCk5RJzpS++7D6pXh6lT4bPPINXuky0OliCMMSVPWBjceaczyN/OnfDmm047RVZWcUd2UbFLTMaYksnPz2m0btECvvsOEhKcQf86d7YvriJiZxDGmJKtYkXnPok77oDKleHrr0kEGD8eMjOLObiyzRKEMaZ0qF/fubFu8GBOgZMwGjaEl1+GI0eKN7YyyhKEMab0EIEmTWgNzix1jRvDX/8KtWvD0KGwYIEN21GI7FKeMaZ06tXLWVauhHffdebB/vRTiIiAAQPghhvgyishoBR9zanCiRNw7BgcPeo8HjsGx49Ddrb7RZUxPgqnFH1yxhjjRtu2Ti+nf/8bpk1zZrB791144w1nHuzOnZ2RYzt2hJYtITi46GPMzj77S9/d62PH3N9FHhjoLAEBZy8iyNklCoUlCGNM2RAS4lxmGjrU+aKdNQvmzIH5852xnsD5Qo2NhVatnOmGo6Odto2wMGepWtXpPVUQVUhPpyFAcrLzX//x478/5v/yP3XKfT0VKjiN8KGhULOm8xga+vu600tQ0HnDeSA+nhFefViesQRhjCl7QkNh0CBnAdi9G375xekmu3y502X2k0/O/m/dz89JEsHBZ/6XruqMFXV6OXECVNkK8P77Z9YREPD7l3x4ODRo4P6Lv0IFz5JRMbIEYYwp++rVc5aBA39fd+oUbN/uJI+DB53lwAHnMTMTcnLOuM5PSAiUL//7Y9Wq3P7443w0ZIiz7vQSFHTW0CCllSUIY8zFKTgYmjVzlgv08eOP81FMTCEGVbL49PxGRHqKyCYRSRKRJ91sLycik1zbfxaRqDzb/uZav0lEevgyTmOMMWfzWYIQEX9gDNALaA7cIiLN8+12N3BYVaOB/wIvuco2BwYDsUBP4E1XfcYYY4qIL88gOgBJqrpNVTOBiUD/fPv0B8a7nk8BrhERca2fqKoZqrodSHLVZ4wxpoiI+mjmJhEZBPRU1Xtcr28DLlXVB/Pss861T7Lr9VbgUuAZYImqfuJa/z7wrapOyfcew4HhrpdNgE0+OZjCFwYcLO4gCklZOZaychxQdo6lrBwHlOxjqa+q4e42lOpGalUdC4wt7ji8JSLLVDWuuOMoDGXlWMrKcUDZOZaychxQeo/Fl5eYUoB6eV5HuNa53UdEAoDKwCEPyxpjjPEhXyaIpUCMiDQQkSCcRucZ+faZAQxzPR8EzFfnmtcMYLCrl1MDIAb4xYexGmOMycdnl5hUNVtEHgRmA/7AB6qaKCLPAstUdQbwPvCxiCQBqThJBNd+k4H1QDbwJ1XN8VWsxaDUXRY7j7JyLGXlOKDsHEtZOQ4opcfis0ZqY4wxpVvJHgjEGGNMsbEEYYwxxi1LED7kwVAjI0VkvYisEZF5IlK/OOL0hAfHcr+IrBWRVSKy2M1d8yVCQceRZ7+BIqIiUmK7JnrwM7lDRA64fiarROSe4oizIJ78TETkJtffSqKITCjqGD3lwc/kv3l+HptF5EgxhOk5VbXFBwtOw/xWoCEQBKwGmufbpwsQ4no+AphU3HH/gWOplOd5P2BWccd9Icfh2q8i8D2wBIgr7rj/wM/kDuB/xR1rIRxHDLASqOp6XaO44/4jv1959n8Ip/NOscd+rsXOIHynwKFGVHWBqp5wvVyCc79HSeTJsaTneVkBKIm9HzwZ/gXgOZxxwc4xy0uJ4OmxlHSeHMe9wBhVPQygqvuLOEZPefszuQX4rEgiu0CWIHynLrA7z+tk17pzuRv41qcRXTiPjkVE/uQaLmU08HARxeaNAo9DRC4B6qnqN0UZ2AXw9PdroOsS5hQRqedme3Hz5DgaA41F5AcRWSIiPYssOu94/DfvupzcAJhfBHFdMEsQJYCIDAXigJeLO5Y/QlXHqGoj4AngqeKOx1si4ge8Ajxe3LEUkq+AKFVtBczh94ExS5sAnMtMV+P81/2uiFQpzoAKwWBgipbw+7ssQfiOR8OFiMi1wN+BfqqaUUSxecvboU8mAtf7MqALVNBxVARaAAtFZAdwGTCjhDZUF/gzUdVDeX6n3gPaFVFs3vDkdysZmKGqWeqM7rwZJ2GUNN78nQymhF9eAqyR2lcLzn8923BOI083WMXm26ctTqNWTHHHWwjHEpPn+XU4d8sXe+zeHke+/RdSchupPfmZ1M7zfADOCMnFHvsFHEdPYLzreRjOZZzqxR37hf5+AU2BHbhuVC7JS6kezbUkU8+GGnkZCAU+d6bBYJeq9iu2oM/Bw2N50HU2lAUc5vcxtkoMD4+jVPDwWB4WkX44w9Wk4vRqKlE8PI7ZQHcRWQ/kAH9R1UPFF7V7Xvx+DcaZ76YkduQ4gw21YYwxxi1rgzDGGOOWJQhjjDFuWYIwxhjjliUIY4wxblmCMMYY45YlCGOMMW5ZgjDGGOPW/wMyJvHZ/hUdhQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.histplot(np.stack(dic['high_low']['fratios']).mean(1), label='high_low', color='r', kde=True, stat='probability')\n", - "sns.histplot(np.stack(dic['curvature']['fratios']).mean(1), label='curvature', color='b', kde=True, stat='probability')\n", - "sns.histplot(np.stack(dic['texture']['fratios']).mean(1), label='texture', color='g', kde=True, stat='probability')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(np.stack(dic['texture']['highsfs']).mean(1), np.stack(dic['texture']['lowsfs']).mean(1))\n", - "plt.plot([0, 1], [0, 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.74978808, 0.58200077, 0.57170733, 0.59208932, 0.39422424,\n", - " 0.49421167, 0.56800983, 0.7208392 , 0.52284125, 0.75522118,\n", - " 0.38187901, 0.44086938, 0.47139352, 0.51878621, 0.56917853,\n", - " 0.77557691, 0.63834333, 0.54907664, 0.46187575, 0.80938305,\n", - " 0.59225197, 0.60802239, 1.05168903, 0.45641054, 0.60753648,\n", - " 0.61701107, 0.83593175, 0.67566611, 0.47884295, 0.41047811,\n", - " 0.80848538, 0.50228611])" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.stack(dic['high_low']['lowsfs']).mean(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([7.6698500394662075], dtype=object)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "params[1]['Lambda2']" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "07-04-2021:04:05:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:05:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:05:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:05:54 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:05:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:05:54 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:05:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:05:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:05:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:05:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:05:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:05:54 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:05:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:05:54 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:05:54 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:05:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:05:54 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:05:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:05:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:05:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:05:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:05:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:05:55 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:05:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:05:55 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:05:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:05:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:05:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:05:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:05:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:05:55 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:05:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:05:55 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:05:55 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:05:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:05:55 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:05:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:05:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:05:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:05:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:05:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:05:55 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:05:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:05:55 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:05:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:05:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:05:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:05:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:05:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:05:55 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:05:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:05:55 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:05:55 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:05:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:05:55 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:05:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:05:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:05:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:05:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:05:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:05:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:05:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:05:56 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:05:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:05:56 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:05:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:05:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:05:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:05:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:05:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:05:56 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:05:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:05:56 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:05:56 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:05:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:05:56 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:05:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:05:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:05:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:05:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:05:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:05:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:02 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:02 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:02 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:02 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:02 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:02 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:02 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:02 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:02 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:02 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:02 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:02 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:02 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:02 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:02 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:02 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:02 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:02 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:02 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:02 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:02 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:02 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:02 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:03 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:03 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:03 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:03 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:03 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:03 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:03 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:03 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:03 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:03 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:03 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:03 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:03 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:03 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:03 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:03 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:03 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:03 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:03 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:03 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:03 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:03 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:03 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:03 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:03 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:03 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:03 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:03 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:03 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:04 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:04 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:04 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:04 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:04 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:04 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:10 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:10 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:10 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:10 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:10 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:10 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:10 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:10 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:10 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:10 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:10 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:10 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:10 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:10 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:10 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:10 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:10 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:10 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:10 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:10 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:10 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:10 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:10 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:10 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:10 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:10 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:10 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:10 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:11 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:11 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:11 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:11 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:11 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:11 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:11 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:11 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:11 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:11 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:11 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:18 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:18 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:18 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:18 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:18 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:18 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:18 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:18 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:18 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:18 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:18 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:18 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:18 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:18 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:18 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:18 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:18 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:18 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:18 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:18 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:18 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:18 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:18 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:18 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:18 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:18 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:18 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:18 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:18 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:19 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:19 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:19 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:19 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:19 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:19 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:19 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:04:06:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:19 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:04:06:19 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:04:06:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:19 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:04:06:19 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:04:06:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:19 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:25 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:25 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:25 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:25 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:25 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:25 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:25 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:25 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:25 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:25 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:25 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:25 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:25 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:25 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:25 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:25 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:25 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:25 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:25 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:25 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:25 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:25 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:25 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:26 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:26 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:26 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:26 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:26 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:26 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:26 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:26 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:26 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:26 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:26 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:26 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:26 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:26 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:26 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:26 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:26 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:26 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:26 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:26 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:26 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:26 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:26 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:26 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:27 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:27 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:27 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:27 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:27 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:33 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:33 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:33 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:33 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:33 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:33 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:33 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:33 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:33 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:33 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:33 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:33 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:33 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:33 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:33 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:33 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:33 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:33 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:33 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:33 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:33 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:33 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:33 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:33 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:33 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:33 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:34 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:34 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:34 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:34 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:34 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:34 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:34 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:34 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:41 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:41 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:41 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:41 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:41 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:41 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:42 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:42 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:48 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:48 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:48 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:49 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:49 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:49 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:49 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:49 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:49 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:50 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:50 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:50 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:50 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:50 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:56 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:56 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:56 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:56 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:56 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:56 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:56 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:56 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:56 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:56 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:56 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:56 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:56 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:56 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:56 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:56 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:56 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:56 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:56 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:56 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:56 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:56 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:56 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:56 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:56 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:56 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:57 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:57 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:57 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:06:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:06:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:06:57 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:06:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:06:57 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:06:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:06:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:06:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:06:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:06:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:06:57 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:06:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:06:57 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:06:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:06:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:06:57 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:06:57 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:06:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:06:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:06:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:06:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:06:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:04 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:04 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:04 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:04 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:04 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:04 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:04 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:04 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:04 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:04 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:04 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:04 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:04 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:04 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:04 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:04 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:04 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:04 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:04 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:04 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:04 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:04 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:05 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:05 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:05 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:05 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:05 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:05 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:11 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:11 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:11 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:11 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:11 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:11 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:11 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:11 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:11 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:11 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:11 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:11 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:11 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:11 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:11 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:11 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:11 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:11 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:11 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:11 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:11 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:11 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:11 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:12 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:12 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:12 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:12 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:12 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:12 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:12 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:12 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:12 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:12 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:12 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:12 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:12 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:12 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:12 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:12 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:12 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:12 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:12 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:12 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:12 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:12 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:12 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:12 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:12 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:12 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:12 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:12 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:13 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:13 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:13 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:13 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:13 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:13 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:19 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:19 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:19 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:19 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:19 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:19 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:19 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:19 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:19 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:19 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:19 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:19 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:19 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:19 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:19 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:19 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:19 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:19 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:19 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:19 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:19 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:19 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:19 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:19 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:19 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:19 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:19 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:19 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:20 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:20 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:20 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:20 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:20 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:20 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:20 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:04:07:20 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:20 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:20 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:20 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:20 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:20 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:20 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:04:07:20 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:04:07:20 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:20 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:04:07:20 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:20 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:20 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:20 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:20 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:20 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:20 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:20 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:20 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:26 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:26 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:27 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:27 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:27 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:27 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:27 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:27 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:27 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:27 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:27 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:27 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:27 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:27 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:27 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:27 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:27 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:27 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:27 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:27 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:27 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:27 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:27 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:27 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:28 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:28 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:28 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:28 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:28 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:28 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:34 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:34 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:34 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:34 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:34 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:34 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:34 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:34 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:34 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:34 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:34 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:34 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:34 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:34 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:34 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:34 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:34 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:34 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:34 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:34 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:34 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:34 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:34 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:35 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:35 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:35 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:35 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:35 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:35 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:35 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:35 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:35 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:35 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:36 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:36 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:36 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:36 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:36 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:42 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:42 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:42 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:42 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:42 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:42 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:43 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:43 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:43 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:43 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:43 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:43 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:43 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:43 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:43 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:43 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:43 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:43 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:43 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:43 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:43 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:43 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:43 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:43 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:43 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:43 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:43 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:43 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:43 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:43 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:43 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:43 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:43 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:43 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:49 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:49 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:49 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:49 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:49 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:50 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:50 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:50 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:50 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:50 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:50 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:50 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:50 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:50 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:50 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:50 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:50 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:50 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:50 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:50 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:50 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:50 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:50 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:50 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:50 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:50 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:50 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:50 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:50 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:50 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:50 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:50 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:50 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:51 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:04:07:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:51 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:04:07:51 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:04:07:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:51 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:04:07:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:51 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:51 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:57 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:57 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:57 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:57 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:07:57 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:57 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:57 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:57 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:57 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:57 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:57 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:07:57 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:07:57 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:57 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:07:57 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:57 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:57 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:57 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:57 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:57 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:57 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:57 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:57 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:58 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:58 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:58 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:07:58 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:07:58 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:07:58 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:07:58 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:07:58 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:07:58 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:07:58 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:07:58 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:07:58 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:07:58 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:07:58 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:07:58 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:07:58 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:07:58 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:07:58 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:07:58 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:07:58 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:07:58 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:07:58 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:07:59 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:07:59 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:08:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:08:05 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:08:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:08:05 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:08:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:08:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:08:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:08:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:08:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:08:05 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:08:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:08:05 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:08:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:08:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:08:05 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:08:05 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:08:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:08:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:08:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:08:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:08:05 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:08:05 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:08:05 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:08:05 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:08:05 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:08:05 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:08:05 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:08:05 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:08:05 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:08:05 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:08:05 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:08:05 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:08:05 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:08:05 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:08:05 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:08:05 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:08:05 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:08:05 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:08:05 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:05 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:08:05 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:05 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:08:05 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:08:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:08:06 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:08:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:08:06 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:08:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:08:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:08:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:08:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:08:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:08:06 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:08:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:08:06 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:08:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:08:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:08:06 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:08:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:08:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:08:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:08:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:08:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:04:08:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:04:08:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:04:08:06 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:04:08:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:04:08:06 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:04:08:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:04:08:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:04:08:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:04:08:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:04:08:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:04:08:06 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:04:08:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:04:08:06 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:04:08:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:04:08:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:04:08:06 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:04:08:06 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:04:08:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:04:08:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:04:08:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:04:08:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:04:08:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" - ] - } - ], - "source": [ - "# 2D tunings\n", - "all_lambda_images, all_lambda_acts, all_psi_images, all_psi_acts, all_fori_images, all_fori_acts = [], [], [], [], [], []\n", - "for key, mask, mask_x, mask_y, param in zip(keys, masks, xs, ys, params):\n", - " lambda_values, lambda_images, lambda_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20)\n", - " psi_values, psi_images, psi_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', 'psi2', None, 20)\n", - " psi_values, psi_images, psi_acts = get_tuning(key, mask, mask_x, mask_y, param, 'psi', 'psi1', 'psi2', None, 20)\n", - "\n", - " all_lambda_images.append(lambda_images)\n", - " all_lambda_acts.append(lambda_acts)\n", - " all_psi_images.append(psi_images)\n", - " all_psi_acts.append(psi_acts)" - ] - }, - { - "cell_type": "code", - "execution_count": 315, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "07-04-2021:08:44:21 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:21 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:21 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:21 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:21 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:21 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:21 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:21 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:22 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:22 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:22 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:22 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:22 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:22 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:22 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:22 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:22 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:22 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:22 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:22 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:22 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:22 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:22 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:22 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:22 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:22 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:22 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:22 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:22 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:22 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:22 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:22 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:22 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:22 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:22 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:23 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:23 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:23 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:23 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:23 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:23 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:23 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:23 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:23 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:23 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:23 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:23 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:23 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:23 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:23 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:23 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:23 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:23 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:23 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:23 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:23 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:23 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:23 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:23 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:23 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:23 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:23 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:23 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:23 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:28 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:28 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:28 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:28 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:28 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:28 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:28 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:28 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:28 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:28 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:28 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:28 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:28 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:28 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:28 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:28 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:28 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:28 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:28 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:28 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:28 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:28 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:28 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:29 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:29 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:29 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:29 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:29 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:29 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:29 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:29 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:29 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:29 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:29 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:29 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:29 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:29 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:29 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:29 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:29 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:29 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:29 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:29 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:29 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:29 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:29 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:29 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:29 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:29 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:29 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:29 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:29 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:30 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:30 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:30 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:30 INFO data_schemas.py 1340:\t Loading dataset group046-22564-2-12-0 --> /external/cache/static22564-2-12-preproc0.h5\n", - "07-04-2021:08:44:30 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:30 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:30 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:30 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:30 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:30 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:30 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group046-22564-2-12-0\n", - "07-04-2021:08:44:30 INFO configs.py 351:\t Found 4425 active trials\n", - "07-04-2021:08:44:30 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:30 INFO configs.py 312:\t Number of samples in the loader will be 4425\n", - "07-04-2021:08:44:30 INFO configs.py 314:\t Number of batches in the loader will be 74\n", - "07-04-2021:08:44:30 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:30 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:30 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:30 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:30 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:30 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:30 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:30 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:35 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:35 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:35 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:35 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:35 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:35 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:35 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:35 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:35 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:35 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:35 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:35 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:35 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:35 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:35 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:35 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:35 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:35 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:35 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:35 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:35 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:35 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:35 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:35 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:36 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:36 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:36 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:36 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:36 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:36 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:36 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:36 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:36 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:36 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:36 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:36 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:36 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:36 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:36 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:36 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:36 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:36 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:36 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:36 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:36 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:36 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:36 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:36 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:36 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:41 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:41 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:41 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:41 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:41 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:41 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:41 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:41 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:41 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:41 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:41 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:41 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:41 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:41 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:41 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:41 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:41 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:41 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:41 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:41 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:41 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:41 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:41 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:41 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:41 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:41 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:42 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:42 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:42 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:42 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:42 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:42 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:42 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:42 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:42 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:42 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:42 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:42 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:42 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:42 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:42 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:42 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:42 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:42 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:42 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:42 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:42 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:42 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:42 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:42 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:47 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:47 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:47 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:47 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:47 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:47 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:47 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:47 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:47 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:47 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:47 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:47 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:47 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:47 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:47 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:47 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:47 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:47 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:47 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:47 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:47 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:47 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:47 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:48 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:48 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:48 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:48 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:48 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:48 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:48 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:48 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:48 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:48 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:48 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:48 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:48 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:48 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:48 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:48 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:48 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:48 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:48 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:48 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:48 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:48 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:48 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:48 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:48 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:48 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:49 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:49 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:49 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:49 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:49 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:49 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:49 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:49 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:49 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:49 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:49 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:49 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:49 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:49 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:49 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:49 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:49 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:49 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:49 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:49 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:49 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:49 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:49 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:54 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:54 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:54 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:54 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:54 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:54 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:54 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:54 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:54 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:54 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:54 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:54 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:54 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:54 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:54 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:54 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:54 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:54 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:54 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:54 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:54 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:54 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:54 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:55 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:55 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:44:55 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:44:55 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:44:55 INFO data_schemas.py 1340:\t Loading dataset group074-22846-10-16-0 --> /external/cache/static22846-10-16-preproc0.h5\n", - "07-04-2021:08:44:55 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:44:55 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:44:55 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:44:55 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:44:55 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:44:55 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:44:55 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group074-22846-10-16-0\n", - "07-04-2021:08:44:55 INFO configs.py 351:\t Found 4495 active trials\n", - "07-04-2021:08:44:55 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:44:55 INFO configs.py 312:\t Number of samples in the loader will be 4495\n", - "07-04-2021:08:44:55 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:44:55 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:44:55 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:44:55 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:44:55 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:44:55 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:44:55 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:44:55 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:44:55 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:00 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:00 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:00 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:00 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:00 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:00 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:00 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:00 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:00 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:00 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:00 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:00 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:00 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:00 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:00 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:00 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:00 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:00 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:00 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:00 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:00 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:00 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:00 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:00 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:00 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:00 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:00 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:00 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:01 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:01 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:01 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:01 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:01 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:01 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:01 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:01 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:01 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:01 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:01 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:01 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:01 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:01 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:01 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:01 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:01 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:01 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:01 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:01 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:01 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:01 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:01 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:01 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:01 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:01 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:01 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:01 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:06 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:06 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:06 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:06 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:06 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:06 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:06 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:06 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:06 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:06 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:06 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:06 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:06 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:06 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:06 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:06 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:06 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:06 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:06 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:06 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:06 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:06 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:06 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:07 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:07 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:07 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:07 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:07 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:07 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:07 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:07 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:07 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:07 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:07 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:07 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:07 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:07 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:07 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:07 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:07 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:07 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:07 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:07 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:07 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:07 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:07 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:07 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:07 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:07 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:08 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:08 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:08 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:08 INFO data_schemas.py 1340:\t Loading dataset group088-23343-5-17-0 --> /external/cache/static23343-5-17-preproc0.h5\n", - "07-04-2021:08:45:08 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:08 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:08 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:08 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:08 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:08 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:08 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group088-23343-5-17-0\n", - "07-04-2021:08:45:08 INFO configs.py 351:\t Found 4449 active trials\n", - "07-04-2021:08:45:08 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:08 INFO configs.py 312:\t Number of samples in the loader will be 4449\n", - "07-04-2021:08:45:08 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:08 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:08 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:08 INFO cores.py 101:\t Ignoring input {'core_hash': '28bc2fa358337c5012278f899b5b6947'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:08 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:08 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:08 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:08 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:08 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:13 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:08:45:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:13 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:08:45:13 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:08:45:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:13 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:08:45:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:13 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:13 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:13 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:08:45:13 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:13 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:13 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:13 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:13 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:13 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:13 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:08:45:13 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:08:45:13 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:13 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:08:45:13 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:13 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:13 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:13 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:13 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:13 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:13 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:13 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:13 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:13 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:13 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:14 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:08:45:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:14 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:08:45:14 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:08:45:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:14 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:08:45:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:14 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:14 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "07-04-2021:08:45:14 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "07-04-2021:08:45:14 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "07-04-2021:08:45:14 INFO data_schemas.py 1340:\t Loading dataset group106-23555-5-12-0 --> /external/cache/static23555-5-12-preproc0.h5\n", - "07-04-2021:08:45:14 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "07-04-2021:08:45:14 INFO configs.py 377:\t Using statistics source all\n", - "07-04-2021:08:45:14 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "07-04-2021:08:45:14 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "07-04-2021:08:45:14 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "07-04-2021:08:45:14 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "07-04-2021:08:45:14 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group106-23555-5-12-0\n", - "07-04-2021:08:45:14 INFO configs.py 351:\t Found 4496 active trials\n", - "07-04-2021:08:45:14 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "07-04-2021:08:45:14 INFO configs.py 312:\t Number of samples in the loader will be 4496\n", - "07-04-2021:08:45:14 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "07-04-2021:08:45:14 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "07-04-2021:08:45:14 INFO configs.py 806:\t Setting cuda=False\n", - "07-04-2021:08:45:14 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "07-04-2021:08:45:14 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "07-04-2021:08:45:14 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "07-04-2021:08:45:14 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "07-04-2021:08:45:14 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "07-04-2021:08:45:14 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" - ] - } - ], - "source": [ - "all_fori_images, all_fori_acts = [], []\n", - "for key, mask, mask_x, mask_y, param in zip(keys, masks, xs, ys, params):\n", - " fori_values, fori_images, fori_acts = get_tuning(key, mask, mask_x, mask_y, param, 'lambda', 'Lambda1', 'Lambda2', None, 20, True, True)\n", - " all_fori_images.append(fori_images)\n", - " all_fori_acts.append(fori_acts)" - ] - }, - { - "cell_type": "code", - "execution_count": 291, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([16. , 4.97877036, 1.54925964, 0.482088 , 0.15001284,\n", - " 0.0625 ])" - ] - }, - "execution_count": 291, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(fori_values[::-1] / fori_values)[idxs]" - ] - }, - { - "cell_type": "code", - "execution_count": 330, - "metadata": {}, - "outputs": [], - "source": [ - "i = 3\n", - "images = np.stack(all_fori_images[i]).reshape(20, 20, 36, 64)" - ] - }, - { - "cell_type": "code", - "execution_count": 331, - "metadata": {}, - "outputs": [], - "source": [ - "idxs = [0, 4, 8, 12, 16, 19]" - ] - }, - { - "cell_type": "code", - "execution_count": 332, - "metadata": {}, - "outputs": [], - "source": [ - "plot_images = images[idxs][:, idxs]" - ] - }, - { - "cell_type": "code", - "execution_count": 333, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(6, 6, 36, 64)" - ] - }, - "execution_count": 333, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot_images.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 334, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 334, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(all_fori_acts[i])" - ] - }, - { - "cell_type": "code", - "execution_count": 335, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(6, 6, figsize=(15, 15))\n", - "for axis, ims in zip(axes, plot_images):\n", - " for ax, im in zip(axis, ims):\n", - " ax.imshow(center_and_crop_image(im, xs[i], ys[i]), cmap='gray', vmin=-2, vmax=2)\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 213, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAoYCAYAAABN0ypRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdebhkRX3/8ffnbrMCwx72wahBVAJIQCVRkBBRE4w7KCoqIfoDQRGNxogG44KiUYPRICK4a4gaEnEhAsEoKIPAsMkiyK7s6yx3+/7+qHOHnp67VM109z19+/N6nvPc7nOq61T37f52dZ1aFBGYmZmZmXWjvtkugJmZmZnZ+nJl1szMzMy6liuzZmZmZta1XJk1MzMzs67lyqyZmZmZdS1XZs3MzMysa7kya2Y9QdLpku6WdNUUxyXpM5JulLRc0p6dLqOZ2VzWrjjsyqyZ9YozgIOmOf4C4EnVdiTwuQ6Uycysl5xBG+KwK7Nm1hMi4kLg/mmSvBj4ciQXA0skbdOZ0pmZzX3tisMDrSpgHQ1pXsxnUXsyV2FyFf5u6O/PTztQkBaI/rLCl6QfGyzLe3xeQTmGxovyHhwYK0vfl59+LMr+n6tXDZWV5eH8tP0rhovyZmS0KHk7Vwl8hAfujYgtJzv2/P0XxX335/1PLl2++mpgVcOuUyPi1MLibAfc1nD/9mrfXYX5WINaxeHSB/QVpFdp3oXfCSXfISXlBqIgfQyU5T02VPidMJifNobKYtPAYNl3wrz+/Fg5r68srg6qrCz9yv/+66fsu/I3V62cMg5Dx2PxesXhOV2Znc8i9tEBbclbA2UvnRYsKErft/FG2WnHN924KO+xTeYXpV+9aX5F7LFtyirWD++cn3Zsh1UzJ2qwzZYPFaXfdnF++gdWLyzK+zfXbluUfruf5KfdeNkdRXmP33NvWfrVq/MTF1Z8/yfOumWqY/fdP8Yvf7RjVj7929ywKiL2Kjq5dcR8FrFP35/nP6DgPVQch0vTDxX8CB0qqIVR/p0QC/J/+UdhWcY2ys979RYFLRDAo9uWfSc8ukN+2uHtyn7Ib7112XfCEza5Lzvt0oX5aQG2GSory2YDj2an3ahvZVHeL3ni8injMHRHLJ7TlVkz614BjBe2MGygO4DGr9Ltq31mZj2rw7F4veJwLfrMSjpI0nXV6LV3T3J8nqRvVcd/IWnpLBTTzDoqGIvxrK1FzgZeV42mfSbwUET0VBcDz/hgZuvqaCxerzg86y2zkvqBzwIHkvpGXCLp7Ii4piHZm4AHIuKJkg4BTgJe1fnSmlmnpNaA1vXXlfQNYD9gC0m3A+8HBgEi4vPAOcALgRuBFcAbWnby7nEGcArw5SmON4403oc00nifjpTMzGZFK2Nxu+LwrFdmgb2BGyPiJgBJ3ySNZmuszL4Y+EB1+yzgFEmKdo5MMbNZFQQjUTZIYtr8Ig6d4XgAR7XshF0oIi6c4crXmpHGwMWSlkjaptdasM16SStjcbvicB26GUw1cm3SNBExCjwEbD5ZZpKOlLRM0rIRCgaumFntjBNZm3VMTrx2HDabY+oei+vQMttS1RQQpwJsrM38LWfWpQIYc0W1KzkOm80d3RCL61CZzRm5NpHmdkkDwCZA2TwYZtZ13OpaO57xwawH1T0W16GbwSXAkyTtLGkIOIQ0mq3R2cDrq9svB85zf1mzuS2AsYiszTqm52d8MOs13RCLZ71lNiJGJR0N/AjoB06PiKslnQgsi4izgS8CX5F0I2kZtENmr8Rm1ikdnWXWPOODmU2q7rF41iuzABFxDilINu47oeH2KuAVnS6Xmc2eIGrfT2uu8YwPZtasG2JxLSqztVGytnbJOtmA+gt7dAzm/2tiXtlygeODbexdUvjzrX84/zUfWV32PFeOlL29h8fy04+OF/7/R8vWJ+8fLpgGZa5eZg8Ym6NPracI1J//2Y2xgvd+YRymoByl6UuXymWgsCwl3wmDZXnHQP7rODavLJaNzi9LPzY//0tkaOFIUd6bLVhRlH6b+flLzu44r2wYzx8MFi5n25+/nO18lb0uM+qCWOzKrJnVUpqo28zMZlM3xGJXZs2spsQYZa06ZmbWavWPxa7MmlktBTAS9Q6gZmZzXTfEYldmzayW0kTd9Q6gZmZzXTfEYldmzay2xmveGmBm1gvqHotdmTWzWuqG1gAzs7muG2KxK7NmVkuBGKvFIoVmZr2rG2KxK7NmVlt1v7RlZtYL6h6LXZk1s1rqhktbZmZzXTfEYldmzaymxFjU+9KWmdncV/9Y7Mpso4KlEYuXpy1c6jDmDWWnHZ9Xlvf4QOEvrJJVfguXvFPBypWMlr3mI2NlSzquKljOdqCvbD2UGCx7YYr+RyXLMHeRtOpMvQOo5VDZsrAlORfG4ZJldQEoyb8w7ygse/QXvDIlaYEoiDel3x/jg0XJGR/Kj5XzB0u+QGDhwHBR+sUDq/Pz7stPC7BR38qi9IuUX/aFGi3KeybdEItdmTWz2qr7pS0zs15Q91jsyqyZ1VKEGInCljQzM2upbojFrsyaWS2lQQf1vrRlZjbXdUMsdmXWzGqq/oMOzMzmvvrHYldmzayWumHQgZnZXNcNsdiVWTOrrbGaT9RtZtYL6h6LXZk1s1rqhiUUzczmum6Ixa7Mmlltjde8n5aZWS+oeyx2ZdbMaqkbRtCamc113RCLXZk1s1oKVPt+WmZmc103xGJXZs2stuo+gtbMrBfUPRbP/cpswbr16iv45dFX+I8tXRN8ID/9+LyyvMcHC9cEL0mev6x2Mp6fVGNlvwzHxgqfZ8Evz3n9ZWtfx8Ky9KPzCxY0L3ivAOXvRZW8jgX/UJj2/dINq87YzCShgvdcjBcEkdI4XBLjoeyz0ubvhCh5DQufZ0n68cKP5HhBKAOIofz//7zBkaK8NxpcXZR+04HHstMu6V9RlPeSvpWF6Yez085rcSNqN8TiuV+ZNbOuFFD7ibrNzOa6bojFrsyaWW3VfdCBmVkvqHss7mjpJB0k6TpJN0p69yTHd5L0E0nLJV0gafuGYydJuqraXtXJcptZ5wViPPI2yyfpdEl3S7pqmjT7Sbpc0tWS/rfaN1/SLyVdUe3/x86V2sxmSzfE4o5VZiX1A58FXgDsChwqademZCcDX46I3YATgY9Uj30RsCewO7APcLykjTtUdDObJWP0ZW1W5AzgoKkOSloC/CtwcEQ8FXhFdWg18LyI+GNSLD5I0jPbWlIzq4W6x+JOnnlv4MaIuCkihoFvAi9uSrMrcF51+/yG47sCF0bEaEQ8BixnmmBsZt0vSBN152yWLyIuBO6fJsmrge9ExK1V+rurvxERj1ZpBqutdMinmXWZbojFnTzzdsBtDfdvr/Y1ugJ4aXX7JcBGkjav9h8kaaGkLYD9gR0mO4mkIyUtk7RshLKRi2ZWJ2Isc7OWejKwadXV61JJr5s4IKlf0uXA3cC5EfGLyTJojMPDsaozpTazNql/LK7bALDjgVMkHQ5cCNwBjEXEjyX9CfBz4B7gImBssgwi4lTgVICNtZlbDcy61ERrgHXcAPAM4ABgAXCRpIsj4vqIGAN2r7oifFfS0yJinb63jXF4k/4tHIfNulg3xOJOVmbvYO3W1O2rfWtExJ1ULbOSFgMvi4gHq2MfAj5UHfs6cH37i2xms8mtro+TNA/YllTBvCci7mnTqW4H7qu6dD0m6ULgj2mIuRHxoKTzSd29phxIZmZzQ91jcSer2pcAT5K0s6Qh4BDg7MYEkraQ1szQ/h7g9Gp/f9XdAEm7AbsBP+5Yyc2s4yJU+35a7SZpI0lvqSqUDwE3kiqPv5N0q6QvVFetWuk/gT+VNCBpIWnQ7bWStqxaZJG0ADgQ+HWLz21mNdMNsbhjLbMRMSrpaOBHQD9wekRcLelEYFlEnA3sB3xEUpC6GRxVPXwQ+KnSal4PA4dFRNmSSmbWVQJqv+pMO0k6DngvcBPph/+HgDuBlcBmwNOAPwPOlXQx8NaIuCEj32+QYu0Wkm4H3k+KsUTE5yPiWkk/JA20HQdOi4irqoaEM6uZafqAb0fEf7fyOZtZ/bQ6Fks6CPg0qS54WkR8tOn4jsCZwJIqzbsj4pzp8uxon9mqMOc07Tuh4fZZwFmTPG4VaUYDM+sZqv2qM232TOC5k/VJrfwSOF3Sm4E3Ac8FZqzMRsShGWk+Dny8ad9yYI+ZHmtmc03rYnHDNK0Hkro0XSLp7Ii4piHZP5B+LH+umsL1HGDpdPnWbQBY6xWtK1+Sb1n/ERWu2z0+kJ9+vL9wHe6BsvTjBenbWvcoHEYSbZzAeeFA/jrZAPMWlaUf3ngoO20MFS5+XvheVMG67THeujdAGnRQ735a7RQRr8xMt5o0L2x9lcTLGM9PO16QFmC8MIiUpi8R3TkuToXFLk1fEudLY/zIeFnr4urx/Ni6Ksri8GORH+MB+gvei8OadHz8emtxLF4zTSuApIlpWhsrswFMrCWwCemK1LSyv3kkbS3peEmfq6bHQtK+knbOzcPMrEQrJ+rOWIFwR0nnS7qsWoXwhS1/QoUk7dYwjsDMbFYUxOItJqblq7Yjm7LKmab1A8BhVTeoc4C3zlS+rCAp6RnAdcBrSJezJmrMB1LNMGBm1kqtXEIxcwXCiUtbe5AGqNahtfMyYIuJO5K+L2mbWSyPmfWYwlh8b0Ts1bCduh6nPBQ4IyK2B14IfGWmH/W5v/hPBj5dBfnGlQh+BOy7HgU1M5vROH1ZW4acFQiLL211QHNN/TmkqbnMzDqmhbF4xmlaSY2m3waIiIuA+TT8qJ9MbmX2GaSRZc3uArbOzMPMLFsEjIWyNmbp0paZ2VxXGItnMuM0rcCtpEVbkPQUUmV22nm1cweArQQ2nWT/LqRlDc3MWq5g0MG9EbHXBp5u4tLWJyQ9i3Rp62kRJSOSWi5Yd0hMd44cMrOu1aoBYJnTtL4D+IKkt5Pi3eER04+YzK3M/ifwfkmvmCiPpKXAScB/lD8dM7PppX5aLRv7lHtp6yBIl7YkTVzams0f7AK+Kmmie9d8UpBf0ZgoIg7ueMnMrCe0OBbnTNN6DYVdWHMrs8dXJ74HWAj8H6l7wc9IgybMzFquhUsorrm0RarEHgK8uinNxKWtM3IvbXVAc/eur85KKcysp9V9OdusymxEPExa3vB5wJ6kvra/ioj/aWfhzKx3tXJuw3Zd2mq3iHjDbJ7fzKwb5vwuWjQhIs4DzgOQVDhTu5lZCTHawiUU23Fpa7ZIGgDmR8Sjs10WM5vrWhuL2yF3ntljJL2s4f4XgZXVBOR/1LbSmVnPavEI2q4k6QBJr2za927gUeBBST+UtGRWCmdmPaEbYnFuy+wxwBsBJD0HeCWpv9nLgE8Af9mW0m0olS3FWbT0beGSoMXpC0TB0rcAY/PK3nCjBelL846CawPRX3bFV4XrKA725y8BuNHA6pkTNViyeGVR+sc23Sg77fjCeUV59w2UrWId/fm/yEXhMoozJG/loIMu9W7gBxN3JO0NfBj4InAt8E7gvdXf+mpX/CuOw238si3Nu3BJ9K5VuvzteP7rMlq4fPaqsbLY98jY/IK0ZdM/DxUuOTvSlx+HB1u8nC3UPxbn/me3A26ubv8V8O8R8W1JVwI/bUvJzKynTaw60+OeTqrQTngF8POI+BsASbcB/0TdK7Nm1rW6IRbnVrUfBraqbh8I/KS6PUIa8Wtm1nLjKGubw5aw9tRg+wI/bLh/Cesu/mBm1lJ1j8W5LbM/Jo3y/RXwRB6/7PVUHm+xNTNrmW4YQdsBdwF/CNwmaR6wB/C+huMbsfYS42ZmLdUNsTi3MnsU8CFgR+DlEXF/tX9P4BvtKJiZWd37aXXAD4CPVYO+DgYeY+2uXbsBN85Gwcysd9Q9FpfMM7vOOuUR8f6Wl8jMDCDq30+rA04AvgP8D2kGg9dHxHDD8TcC585GwcysR3RBLC4b2gdI+gNgqHFfRNzashKZmVFd2prb/WFnFBH3As+RtAnwaEQ0D1N+BamSa2bWFt0Qi7Mqs1Ug/QxpSq6hSZLUezZdM+tKdW8N6JSIeGiK/fdPtt/MrJXqHotzW2ZPBv4Y+GvSJa83kkbQHktaAtLMrKWC8nkkzcystbohFudWZl8AHBoRP5U0BlwaEd+SdBfwt8BZbSuhmfWkbpjb0MxsruuGWJxb1V4C3FLdfgjYvLp9EfDsFpfJzAyo/9yGnSBpiaQXSXq2tPayUZIWSTphtspmZr2h7rE4tzL7G+AJ1e1rgUOqoPpSwH22zKz1IvXTytnmKklPJcXc/wT+D7hE0k4NSRYDnlXGzNqnC2JxbjeDM0jzGV4AfBT4b+BoUmX42HYUrDUEKujnUbC2tkrX1S5MHwVrjo8PlOU9Oq8w/YKCtbIXFmXN2IKChbsHx4vyHhooW596fv9IdtqNBlcV5f0Hix4pSn/Nki2z044tGizKu2+oLL1W5v//o+TzNlNe1H/QQQd8hHQF7LXAxsCngZ9J2j8ibpjVkuXqEyp4z8Xw8MyJJvQXjj0uTK+BgvSlZSnJG6C/4HPYX/Y5jJK8Cz/ixelV8J1QI2PZbYPrmX/BC9lPa1/DbojFufPM/nPD7fMk7QLsBdwQEVe2q3Bm1tvqHkA74JnA/hHxGGnBhFdK+iRwgaT9Sd2+zMzaqu6xuHieWVgzr6znljWztumGQQcdMA/WbmaJiOOqbl4XAK+ejUKZWe/ohlicXZmVtA9wALAVTX1tI+KYjMefDvwlcHdEPG2S45sCp5PWIV8FvDEirqqOvR04ghTUrwTeEBFl13nNrOtEzQNoB1xHugp2TePOiHi7pD5SX9oiknYAvgxsTYqpp0bEp5vSvAb4O0DAI8BbIuKK6tgS4DTgadXj3xgRF5WWw8y6R91jcVYnDEnHk/ptHQ7sDjy9YVunYjqFM4CDpjn+98DlEbEb8DpS3zAkbQccA+xVVYL7gUMyz2lmXazuI2g74LvAoZMdiIhjga9C8QswCrwjInYldWM4StKuTWluBp4bEU8HPgic2nDs08API2IX0vzj1xae38y6TN1jcW7L7LHAMRFxyvqeKCIulLR0miS7kgaXERG/lrRU0tYN5VwgaQRYCNy5vuUws+4QUf9+Wu0WER8hDQKb6vhRwFGFed4F3FXdfkTStaRFcK5pSPPzhodcDGwPa1aDfA6pYYOIGAYKRmyZWbfphlicOzxuY+CcdhYEuII01ReS9gZ2AraPiDtIK5DdSgrAD0XEj6fKRNKRkpZJWjbinghmXUyMjfdlbbZ+qgaGPYBfTJPsTcAPqts7A/cAX5J0maTTJC2aJN81cXh43HHYrLvVPxbnnvkbTN9FoBU+CiyRdDnwVuAyYKzqS/tiUhDdFlgk6bCpMomIUyNir4jYa1Dz21xkM2unCGVtVk7SYuA/gLdFxMNTpNmfVJn9u2rXALAn8LmI2IM0w8K7mx/XGIeH+hyHzbpd3WPxlN0MJB3XcPc24B8l7QssB9aakDMiPrmhBamC6Ruqc4vUZ+sm4PnAzRFxT3XsO6RVx766oec0s/rqhrkNO0XSjsBtERFN+wXsUM0wU5LfIKki+7WI+M4UaXYjDfR6QUTcV+2+Hbg9IiZacs9iksqsmc0d3RCLp+sz+9am+4+SKpHNy9cGsMGV2WqE7IqqD9YRwIUR8bCkW4FnSloIrCTNqLBsQ89nZjUXqa+WAenH/TbA3U37N6uOZc/AX1WAvwhcO1VDRFV5/g7w2oi4fmJ/RPxO0m2S/igiriPF42smy8PM5oguiMVTVmYjYudWnkjSN4D9gC0k3U5agnGwOtfngacAZ0oK4GrSpS0i4heSzgJ+RRqFexlrj6w1szlqjs9UUEIw6bI+i0lTGZbYl7Si2JVVty5Is8nsCGvi8QnA5sC/VqsdjkbEXlXatwJfkzREunr2hsLzm1mXqXssLl40oepnRUQ8WvK4iJh0epmG4xcBT57i2Pvx+uNmPSWo/9yG7SbpM9XNAD4iaUXD4X5gb+Dykjwj4v+YYTqviDiCdIVssmOXk+a+NbMe0A2xuGTRhLcBx5GmcEHSnaTuBZ9q7sdVFwJUskZ1X0Hadq/DPZBflrF5ZW+y0fmF6Rfmpx9dZ1zzDOkX5L91+heMFeW9cF7ZjEGbDOY3cG0xWPRbjvFFZa/5FZvvmJ12ZJP8de8BhgbL0kdBeq3dnX4D1X/VmQ54evVXpKtXjW/qYdIVq5M7Xagi6kPz8weB9Y2M5uc9VPZeVuF7n/nzspPG/KGirMeHytqSxgfzv0Oiv+xzMz6Qn35ssCzvKG0yG8z/Tpg3UPadML+/4L0FLOzL/w5Z1Le6LG+Vpd+4L//7aVBlr8vM6h+Ls95mkj4GHAl8nLR4AsCzSJeitgHe1ZbSmVlPq+fP5M6JiP0BJH0JOHaqWQfMzNqp7rE49zfTEcAREXFWw77zJF0H/BuuzJpZG9T90lanRIT7pZrZrKl7LC65ALB8in2esdzMWi6i/gG0kyS9ijR7wFY0xd2IOHhWCmVmc143xOLcyuyXSUsmHtu0/y3AV1paIjOzyth4vQNop0j6OPA24HzSct41v+hnZnNJ3WNxbmV2HvBqSc8nrdMNsA9pRa6vNYy4JSKOaW0RzaxX1b01oINeBxza1NXLzKwj6h6Lcyuzu5BGzQLsVP39XbU9pSGdWwvMrCUCL1XboI/CKbjMzFqhG2JxVmV2YkStmVkn+dfxGqcChwEfmOVymFkPqnssLl40wcysI7pg0EEHLSF19TqQNPB2rQl93b3LzNqmC2KxK7NmVl91bw7onF15vJvBLk3H/CqZWXvVPMq4MmtmtVX31oBOcVcvM5tNdY/Fc7syK0HJUpwq+GcVLqMYhcvZjs3LT1+6nO1Y4XK2IwVL1I4uKvv5Fgvzl92bv6Bwedp5+cv/AWw29Fh22q0GyxZimtdXtszr0JL8pQ5Xb7ywKO9FpUuADuSHieIf7ytnyK/mrQGWoU/EwvzlbBnNX3JUBcvNAkRp3F6Qv0RtzCvLe3yo7DthfCh/SvfxwbLp30cX5qcvWd4cYKTwO6F/Yf7/f8mCGQJIk63nlcXtrQcfyk673cADRXlv2Z//fQOwSV/+d+UitX76/1bGYkkHAZ8G+oHTIuKjk6R5JWmMQABXRMSrp8tzbldmzaxrBfVvDegkSS8AjgaeAPxFRNwm6Qjg5oj4yeyWzszmqlbGYkn9wGeBA4HbgUsknR0R1zSkeRLwHmDfiHhA0lYz5btB1XdJfZJ23JA8zMwmFUAob5vjJL0G+DZwPbAUmGgG7MfLiZtZO7U2Fu8N3BgRN0XEMPBN4MVNaf4G+GxEPAAQEXfPlOm0lVlJ8yV9XtI9kq6X1LwC2JbAzTmlNzMrFeN5Ww94F/A3EfF2oPE67MXA7rNSIjPrGQWxeAtJyxq2I5uy2g64reH+7dW+Rk8GnizpZ5IurrolTGumbgYnAH9Z/d0E+AdJfwK8LmLNV8jcbxYxs1lQ/4m6O+hJwEWT7H8U2LjDZTGznlIUi++NiL028IQDpJi3H7A9cKGkp0fEg1M9YKZuBq8itQZ8ruqguxewJ/B1aU0PYw/RMLP2iMwtg6SDJF0n6UZJ754izSslXSPpaklfb8EzaJU7Sa0VzZ4D/KbDZTGzXtO6WHwHsEPD/e2rfY1uB86OiJGIuJnUvepJ02U6U2V2G+DaiTsRcQuwP/B0Uj+HsuGbZma5qom6c7aZNAw6eAFpztZDJe3alKZx0MFTgbe1/Dmtv1OBz0jat7q/g6TXAx8DPjd7xTKzOa+FsRi4BHiSpJ0lDQGHAGc3pfkeqVUWSVuQfsjfNF2mM3UzuAt4IvDbNc8p4veSDgDOB76cU3Izs/XSuus+awYdAEiaGHRwTUOa4kEHnRIRH5O0CXAuMJ8Uf1cDJ0fEZ2e1cGY297UoFkfEqKSjgR+RBrCeHhFXSzoRWBYRZ1fH/kLSNcAY8M6IuG+6fGeqzJ4PvBr4n6bC/E7S84D/Xb+nY2aWI7uf1haSljXcPzUiTm24P9mgg32a8ngygKSfkYLsByLih2XlbZ+IeK+kD5FalvuAayLi0Vkulpn1hNaNX4iIc4Bzmvad0HA7gOOqLctMldkPsu7SiRMnu0vSc4G/yD2ZmVmR/NaAWRl00EmSXgUcAGxF1UVsYqGXiDh49kpmZnNezUdHTVuZrfrI3jLN8buAM1tdKDMzoJUBNHfQwS8iYgS4WdLEoINLWlaK9STp46Q+vOeTBoPV/KvFzOaUmkccrwBmZvU0MVF3a6wZdECqxB5C6kLV6HvAocCXcgcddNDrgEMj4qzZLoiZ9ZjWxuK2mNuVWQn1FyxyVrCeccl69VC+Jvj4vPx1u8eGyt5kYwXLpAOMFqytPbo4f/1ogIFFI9lpN1lYtg73NgvK1uHecd79+WkHp+2Lvo7H+svWkN90oxXZaUcWLirKOwYLP/YFnyFFa9cEb9V64O0adNBBfcDls12I9dLXR8wbyk8+lJ+2JF+AmF8YhwvSjy8o+1yNFcR4gPGB/Dg/XvidMLIw/3M7urAoa8YWlq1qMn9e/nfCRoOrivLedDA/rgIs6c9Pv6Sv7Ptps76y78pN+vLf6wsL0uZqVSxul7ldmTWz7jZe70EHHXQqcBjwgVkuh5n1ohbG4nZwZdbMaks1bw3ooCXAqyUdCCwH1mq+iohjZqNQZtYb6h6Ls64tSDpP0pJJ9m8s6bzMPHaQdH7D6jrHTpJmU0nflbRc0i8lPa3h2Nurx10l6RuSCi+Wm1lXyV1xpuZBtkV2JXUzGCbNMPP0hu1pUz9sXZmxeBNJ/yXpiirNGxqOnVTF4auqGRbMbC7rglic2zK7HzBZJ4z5wJ9l5jEKvCMifiVpI+BSSedGROOk5X8PXB4RL5G0C2nFngMkbQccA+waESslfZs0gOOMzHObWddR7QcddEpE7N/C7HJi8VGkeWz/StKWwHWSvgYcSFrSfHdgHnCBpB9ERFkHdTPrIvWPxdNWZiXt2XB3N0mNI2T6geez7vQ2k6qm8bqruv2IpGtJE5k3BtBdgY9WaX4taamkrRvKukDSCLCQND2Nmc1lvdHq2lGZsTiAjZQmsl0M3E+qBO8KXBgRo8CopOXAQcC3O/gUzKzTah6LZ2qZXcbjjcc/nuT4SuCtpSeVtBTYA/hF06ErgJcCP5W0N7ATsH1EXCrpZODW6pw/jojJyoOkI4EjAeb3lY3yNrOaqXkA7aTqh/1RpAplkCqf/xoRv9+APJcyeSw+hbRe+p3ARsCrImJc0hXA+yV9gtSosD9rV4In8n08Dg9uvL7FM7O6qHksnqnP7M7AH5LWMdu7uj+xbQdsHBGnl5xQ0mLgP4C3TXJp6qPAEkmXkyrJlwFjkjYlraO+M7AtsEjSYZPlHxGnRsReEbHXkBaUFM3M6qbm/bQ6RdK+wI2kuXFXAquA1wA3SHrWeuY5XSx+PqmP7rakLgWnSNq4akQ4B/g58A3gItI0ZmtZKw4PuFHBrOvVPBbnrAAGmQPFZiJpkBQ8vxYR35nkfA8Db6jSCriZNGn584GbI+Ke6th3gGcDX21Fucyshrpgou4OOplUeXxzRIwDSOoDPg98ghQPs80Ui0lx+KPVdGU3SrqZNPDslxHxIeBDVT5fB65fv6dkZl2hC2Jx9tRckrYHnkPDuuATIuKTGY8X8EXg2qnSVzMmrIiIYeAIUt+shyXdCjxT0kJSq8QBpC4QZjaH1X06mA7aHTh8oiILUF32/yTpCla2nFhM6tJ1AKnL19bAHwE3SeoHlkTEfZJ2A3Zj8i5oZjaH1D0WZ1VmJb0GOJ00AOAe1m5MDmDGyiywL/Ba4MqqGwGk2Qt2BIiIzwNPAc6UFMDVwJuqY7+QdBbwq6oMl5EmETezuazmAbSDHiJ1s7quaf/OwIOFeeXE4g8CZ0i6ktTN7O8i4t5qSsSfpvowDwOHVYPBzGwuq3kszm2ZPZF0Ket9EVG2BlslIv6PFBSnS3MRaT30yY69H3h/8YkLlqilr33N6DFQ1lNjbCg//VjhynWjpcvZLs5/F2tx2ffa4kX5yxFuueCxory3X/BAUfqdhu7JTvuEwfylbwFWjJetT7LZgvxlFO+aV/i+HShbRpP+gvRjZUtXzqTurQEd9E3gi5LeReqvCqlSehKp+0G2zFh8J/AXk+xfRRqAVqa/4D1aEodLlisHouS9TFncHi8sy/hg4TLkBd8JheGm6DtkvGxFYGKg7EPc358fQwb6WhtvbGp1j8W5b/mtgdPWtyJrZrZeat5Pq4PeRaqAns7jcXsE+Bzw7tkqlJn1iJrH4tzK7DnAPqTBWGZm7dcjMxXkqMYRHCvpPaQZZgB+ExH5TfhmZuujC2JxbmX2XOAkSU8FrmTddcEnGw1rZrZhah5AOy0iVlQzC+CKrJl1TM1jcW5l9t+qv38/ybEgrQZmZtZSde+n1UmS3gYcR5rjG0l3kgbffqqaQsvMrC3qHouzKrMR0ZJ5Zs3MitQ8gHaKpI+RVtT6OGmhAoBnAScA25D61JqZtUfNY3HhmEczsw6qeQDtoCOAIyLirIZ950m6jnTlzJVZM2ufmsfirBZXJf9P0tWSVkh6QrX/3ZJe2d4imlkvUuRvPWL5FPt85czM2qYbYnFuEDwW+AfSQgWN8zPcARzd6kKZmQFpOpicbe77MnDUJPvfAnylw2Uxs15T81ic283gzcDfRMT3Jf1Tw/5fAU9tfbHMzKj9pa0Omge8WtLzgYurffsA2wJfk/SZiYQRccwslM/M5rKax+LcyuxOwFWT7B8BFrSuOGZmj5MX+JmwC6nxAFI8BvhdtT2lIV3Nv3LMrBvVPRbnVmZvAvYEbmna/0LgmpaWyMwMoLf6w04rIvaf7TKYWY/qglicW5k9GThF0kJSn9lnSXotaQTtG9tVuDml9FdNwZCO8YGyfirjBetwA4wvyF/FeP6CkZkTNdhkwarstFvOf7Qo720GHyxKv91AfvptC9d4f0Rlr8vGQ/mvy12Fw3+iv+z90qf89C2PdzUPoJZprOAfOVYQLMfL3iAqnY63IHlx3t2q8GlqvCzejI7mx9ZVY4NFeT8yNr8s/Xh++gfHyy5Sz1P+92oynJ1yhNK8M9T87Z07z+yXJA0AHwYWkgYc3AkcExHfamP5zKyX1TyAdpKkrYF9ga1o+rkbEf86K4Uys95Q81icPc9sRHwB+IKkLYC+iLi7fcUyM6v/pa1OkXQYcBrpytgDrP3VEoArs2bWNnWPxcWLJkTEve0oiJmZTelDwMeAEyNidLYLY2ZWJ1mVWUmbkYLpAUx+iWvj1hfNzHpezVsDOmhj4AxXZM1sVtQ8Fue2zH4R2IO0aMKd1P5pmVnX64IRtB30NeBFwL/MdkHMrMd0QSzOrcweABwYEb9oZ2HMzNZS8wDaQccB35N0AHAlaY7vNSLixFkplZn1hprH4tzK7N1A2bxIZmYbquYBtIP+FjgIuBd4IusOAHNl1szap+axOLcy+17gREmvjwhXas2s7UT9L2110PuAd0TEP892Qcyst3RDLM6tzP4DsBS4W9ItrHuJa7cWl8vMel3UfwnFDuoHzp7tQphZD+qCWJxbmT2rraUwM5tMzVsDOuhLwGtwdwIzmw01j8W5K4D9Y7sLYma2jpoH0A5aCBwh6fnActa9OnbMrJTKzHpDzWNx0aIJkp4H7Ep6WldHxAXtKFRLRUHbeMlyxmNlax9rpGx6SI3mv3P6StY9ByJ/6etkID//ocGy57l4aHV22iWDK4ryXtJfmL4vf+3rxX2Li/JeFY8VpR8d75s50YQ2X/6JkjXnSz5vGereT6uDngJcVt3epelYvV+liLL4N1qQtjAOM1r2/uwbyc8/Bgo+s4AKi95X8J2QejkW5D0yc5rHy1GUNRopK8voSP4X1CPD84ryfmR0flH6B8cW5qftz08LMKiyF3Kc/O/KFVH45spQ91icu2jCdsB3gWeQ5pkF2FbSMuAlEXHnlA82M1tfNQ+gnRIR+892Gcysh7UwFks6CPg0aSzAaRHx0SnSvYzUzfVPImLZdHnm/pT8DKnd8okRsUNE7AA8qdr3mcw8zMzyRcHWAyRtLelESWdJ+ndJH5C01WyXy8zmuBbGYkn9wGeBF5Cu9B8qaddJ0m0EHAtkrW+QW5k9EDgqIm6e2BERNwHHVMdmJGm+pF9KukLS1ZLW6YcraSdJP5G0XNIFkrav9u8v6fKGbZWkv84su5l1KUXeNtdJ2he4EXg1sBJYBRwG3CjpWYV55cTiwyXd0xBzj6j27yTpV9W+qyW9ecOfnZnVXQtj8d7AjRFxU0QMA98EXjxJug8CJ5Fi3YxK+sxOVsySr5HVwPMi4lFJg8D/SfpBRFzckOZk4MsRcWbVP/cjwGsj4nxgdwBJm5GC+o8Lzm1m3agHKqqZTga+Abw5InVMltQHfB74BPDsgrxyYjHAtyLi6KZ9dwHPiojVkhYDV0k6213NzOa4/Fi8RdUFdcKpEXFqw/3tgNsa7t8O7NOYgaQ9gR0i4vuS3plz0tzK7E+Af5F0aETcVp1sR+BT1bEZRRpFMrHgwmC1Nb88u5KWbQQ4H/jeJFm9HPhBRJSN7jGzrtMLra6ZdgcOn6jIAkTEuKRP8vjAsCyZsXiqxzaOkpxH/tU9M+tiBbH43ojYa73Pk36kfxI4vORxuYHoGGARcJOkW6qFE35T7cueEkZSv6TLScvjnhsRzX0hrgBeWt1+CbCRpM2b0hxCaqGY6hxHSlomadlwrMwtmpnVkfvMTngI2HmS/TsDD5ZmlhGLAV5Wdfk6S9IODY/dQdJyUuvKSZO1yq4Vh0fd7mDW9VoXi+8Admi4v321b8JGwNOACyT9FngmcLakaSvIWZXZqjV2T+CFpMtdJwMviIg9I+L2rOKnfMYiYveq8HtLelpTkuOB50q6DHgu6QmumWNC0jbA04EfTXOOUyNir4jYa0gLcotmZjWT20erR1pvvwl8UdJrJO1cbYcBpzHNj/upZMTi/wKWVqs7nguc2fDY26r9TwReL2nrSfJ/PA4PlE1ZZGb10uJYfAnwpCqGDZEaKNesbhgRD0XEFhGxNCKWAhcDB880m0F2n9nq0tS51bZBIuJBSecDBwFXNey/k6pltuqP9bKIeLDhoa8EvhsRBbPimVnX6o2Kao53kSYPPZ3H4/YI8Dng3eub6TSx+L6GZKcBH5vksXdKugr4M7xKpNnc1qJYHBGjko4mNUr2A6dHxNWSTgSWRcR6Ldud3d9J0l9LulDSvdX2U0kvKXj8lpKWVLcXkGZB+HVTmi2q/hIA7yEF7kaHsh6tEGbWnVrZMivpIEnXSbpR0pQVQEkvkxQzXdbqpIgYjohjgU1J/Wd3BzaLiLc39WOdUWYs3qbh7sHAtdX+7avHIGlT4E+B69bjKZlZF2llLI6IcyLiyRHxhxHxoWrfCZNVZCNiv5laZSF/0YR3AB8GvgycUe1+FvB1Se+LiJMzstkGOLOaY6wP+HZE/HdTbXw/4COSArgQOKqhDEtJ/Sz+N6fMZjYHtKg1QI/PbXggafTsJdUo/Gua0hXNbdhp1cDXKzcwm5xYfIykg4FR4H4eH4zxFOATVYwWcHJEbGh5zKzuan6VLLebwfHA0RHxhYZ9p0v6JXAiqQ/ttCJiObDHJPtPaLh9FlNcroqI35KmdMgXQZQso9hXMDC3ZMlFQMNlPSMGVuQvR9c3PFiUd99o2fKCjBWmL9BX0OGxJC3AYOF6kSXDsscKl219ZLys7A+szu9n2D9clrcKl/QsWTK06POWlWHLcloztyGApIm5Da9pSjcxt2HWdDDtJukFpK4Eu0XEw03HNiENmv2biMju/pUZi99DujrWnOZcYLfsJwAwHkXxLwpia+ky4fQXruXdnx/7+gqXs+1fXRpX88uuwnjTP1zwPAvSAvQVPs+x4fznuXKk7Lvv4ZGy5WwfGm3fcrbz1b7ekvMLl8rNUvPKbO6nbzFpqqxm51fHzMxaq2zQwRYTo+er7cim3Cab23CtH8eNcxu282kVOhr4eHNFFtJACVLF+22dLpSZ9ZAuGIyb2zL7PdL8rs3r576MhlFoZmYtVfO5DTtgNx6fe3sy5wHv7VBZzKxX1bxlNrcyeyPwbkn7AxdV+55ZbZ+UtCbYRsQnW1tEM+tVLfylXzK3IcAfkOY2nHFKmDbbEpiuX0gAzXNxm5m1VN2nQMytzB4OPAA8udomPAC8oeF+kFo3zMw2XOsC6Jq5DUmV2EOAV685Tbpkv8XEfUkXAMfPckUWUneI3YAbpji+G2tXys3MWm8uVGYjYrKVZ8zM2qpVrQHtmtuwA74PfFDSORFrL2koaSFpAG6d+via2Rw0V1pmzcw6K5j+AntpdhHnAOc07TthirT7te7MG+RDpPEK10s6hcfng30KaXCYSNMmmpm1R4tjcTtkV2arBRL2B7aiaRaEiHhli8tlZj1O1L81oN0i4m5JzyZNz/Vh0ssC6evlR8BREfH72Sqfmc193RCLcxdN+ATwVuBnwO+Bsgk8zczWR80DaCdExC3AC6sVt55I+m65ISIemN2SmVnPqHkszm2ZfT3wioj4z3YWxsyskaLmEbSNJO0cETdP3K8qr5dMkVbA9hFx22THzcw2RN1jce6iCStoWrvbzKytomCbmy6S9EVJz5oqgaRNJb2FtJLZiztXNDPrGV0Qi3NbZj8KvEvS30ZEG9ZJMzNbV937abXZLqQFEb4vaRy4FLgTWAVsCuxKGgj2S+BtEfGj2Sqomc1tdY/FuZXZLwB/Bdwh6XpgrUWFI+J5rS5YS0QUrStPSTN6wVrj65O+/9Hh7LTzHhkqynvVirL1ybUyP/2q1WVrZa8czU+/erxs8o1VUVaWFZH/PB8eX1WU9w0jmxal/91DG2Wn3XhFYZQpfe+OFvx+Lfm85ah5AG2niHgQeKekE4AXAX8K7AQsAO4FzgR+FBFXzVohc0TASMF7qOT9VvheVn9Z7KNPM6dZkzQ/LUAU5F1qvL8s7/7h3Iu00L+67EPZn/9VBsDo6vyyrBwui/GPjswrSz+Wn/6RsQVFeS/sW12UvsQqtaHNseaxOLd28HlSIP0haQBYzZ+Wmc0FdW8N6IRqftmzqs3MrOPqHotzK7OvAl4SEee2szBmZmupeQA1M+sJNY/Fue359+AlE82skyK1BuRsvUTSAknbTbL/qbNRHjOb47ogFudWZt8PnChpcTsLY2Y2QYDG87ZeIenlwA2kQWHLJe3TcPgrs1QsM5vDuiEW53YzeCewFPi9pFtZdwDYbi0ul5lZ2aDM3vAPwDMi4veSngGcKenDEfF1Hl8dzMystWoei3Mrsx54YGYd12tdCDIMTixfGxGXSnoO8F1JT6T2vdrMrFvVPRZnVWYj4h/bXRAzs7XM7QUR1tfdknaLiOUAEXG/pANJ03T5CpmZtV4XxOKiiTslPY80UXcAV0fEBe0olJkZ9FZ/2EyvBdaaRDIihoFDJZ0yO0Uys7mu7rE4qzJbjZz9LvAM0go0ANtKWkaasuvOKR9sZra+at4a0GkRcfs0x37WybKYWQ+peSzObZn9DDAGPDEibgaQ9ATgq9Wxl7eneGbWy+reT6tTJJ0+xaEgLW97I/AtNyyYWTvUPRbnVmYPBPabqMgCRMRNko4BftKWkplZbwtqP4K2g7YE/gwYByaWr30aaQaDS4GXkqZP/LOIuHxWSmhmc1MXxOKSPrOTPZNaP7sAYqygo0dJ2lKry9Zh7ntsVXbaoQfnF+U974H8ta8BhjfKn/FnePFQUd73L8xfz/r+hQuL8r5ndKOi9L8byJ9G+bHI//8AXLZyaVH6FffnP9ctHxoryluryhZLHx/JX+e76POWoe6tAR30M+BR4E0RsQJA0kLgC8AVwAuBLwOfAA6YrUJOKoIYGZk53UTygvcbg4Xv/eH8cgDQlx/7pLKZ0fr62zeTmgbLYvzAqvzPbf/qsrz7Vpc9T43k5z88UjTsh5Wjg0XpHxubl512xXjZd9+K8fy8AfoLqluD6i/KO0fdY3Huu+YnwL9I2mFih6QdgU/hllkza5fI3Oa+Y4ETJyqyANXtDwFvrwaBnQTsPjvFM7M5reaxOLcyewywCLhJ0i2SbgF+U+07pl2FM7PepQg0nrf1gMXANpPs/4PqGMDDFM5QY2Y2k26IxVmV2Yi4DdiTdCnr5Gp7QUTsOd3o2slI6pd0maT/nuTYTpJ+Ui3TeIGk7RuO7Sjpx5KulXSNpKUl5zWz7lP39cA76LvAFyW9QtLSansF8EXgO1WavYHrczOcIRY/R9KvJI1WS+g2HnMsNusxdY/F2b/iIyKAc6ttQxwLXAtsPMmxk4EvR8SZ1Zy2HyHNqwipP9iHIuJcSYtJAyHMbC7rjYpqjjcDnyTNIDMRt0eB04Hjq/vXAn9TkOd0sfhW4PCGvBs5Fpv1mprH4mlbZiW9QNJvJa0T7CRtUh07MPdkVUvri4DTpkiyK3Bedft84MXV43YFBiLiXICIeLSx75iZzU11bw3olIhYERFvBjYD9qi2zSLiLRHxWJXm8tyZDGaKxRHx22qVsfGmxzkWm/WgusfimboZHA18PCIebj4QEQ+RBhy8reB8nwLexdS/5K8gTTED8BJgI0mbA08GHpT0neqy2MelyYfrSTpS0jJJy0YKR5ybWY0EMB55W4+IiMciYnm1PbYBWX2K6WPxVLJicWMcHh5fuQHFNLNZ1wWxeKbK7G7A/0xz/Dzgj3NOJOkvgbsj4tJpkh0PPFfSZcBzgTtIizUMkOZYPB74E+AJpEtg64iIUyNir4jYa1BlU1aZWc3UfARtJ0naWtKJks6S9O+S/lHS1uuRT04snkpWLG6Mw0N9+dPvmVlN1TwWz1SZ3ZLpf7kHsHnmufYFDpb0W+CbwPMkfXWtzCLujIiXRsQewHurfQ8CtwOXR8RNETEKfI80IM3M5rC6X9rqFEn7klb5ejWwkrTq12uAGyQ9qzC7GWPxNByLzXpQ3WPxTJXZ20mts1PZjdR6OqOIeE9EbB8RS4FDgPMi4rDGNJK2kDRRpveQBjcAXAIskbRldf95wDU55zWzLhaRt819JwPfAJ4cEa+NiNeSLvl/k7RQQracWDwNx2KzXlTzWDxTZfb7wAclrXOdqFp95sQqzXqrLpsdXN3dD7hO0vXA1qQJwYmIMdJlrZ9IupK0hOMXNuS8ZlZ/dW8N6KDdgU9ExJorZdXtT5IGg22wxlgs6U8k3Q68Avg3SVdX53QsNutBdY/FM03N9SHg5cD1kk4Bfl3tfwppcJiAD5eeNCIuAC6obp/QsP8s4KwpHnMu07cST/YgYqxsucNsBcscAmi0YIlGQCvzl78deqhsedIF95XNqz6yMH9pvLEFZXk/UrCc7d2LypanvWPepkXpN+rLHzDYr7JxM5c+tGNR+qG781/HoQfLBtjE6rL3SxS8d1v6eeuh/rAZHgJ2Bq5r2r8z8OD6ZjpNLL4E2H6Kx5TF4ggoWUa25D00UvZepr9sKVYVLMVa+lZVX+GysAXL5UbhQJy+guVvB1aX5d1fupztcH760ZGyZVtLl7NdOZafftV44VK5hcvZDir/czFGi5dK7oJYPO03ZkTcLenZwOdIldaJVyiAHwFHRcTv21tEM+tFAjRW8wjaOd8kLZrwLuDn1b59STPKfGPWSmVmc143xOIZm38i4hbghZI2BZ5Iel43RMQD7S6cmfU29UZ/2BzvIsXe00lxW8AwqaHh3bNYLjPrAa2MxZIOAj4N9AOnRcRHm44fBxxBWhjmHuCNVV10SiUrgD1A6vxvZtZ+XXBpq1MiYhg4VtJ7gD+sdv/GCxaYWdu1MBZX81J/FjiQNMnAJZLOjojGgaSXAXtFxApJbwE+BrxqunzLOjiamXVMz8xUMClJZ2ekASAiDp4hqZnZemppLN4buDEibgKQ9E3Saq9rKrMRcX5D+ouBGWdbcWXWzGqrR2YqmMp9s10AMzNoaSzeDrit4f7twD7TpH8T8IOZMnVl1szqq4dbZiPiDbNdBjMzoCQWbyFpWcP9UyPi1PU5paTDgL1IK8JOy5VZM6ungMIZ0MzMrNXKYvG9EbHXNMfvAHZouL89kyy+JenPSSvBPjciZpyr1JVZM6uvHm6ZNTOrjdbF4kuAJ0namVSJPYS0TPcakvYA/g04KCLuzsnUlVkzqy/XZc3MZl+LYnFEjEo6mrRWQT9wekRcLelEYFlEnA18HFgM/Hs1yPXWmQa5ujJrZrXleWbNzGZfK2NxRJwDnNO0r3EFwj8vzdOVWTOrpwBqvuqMmdmc1wWxeO5XZscL1vkuWPu6aP1wIEby17cH0Gh++r4VZeuTz3ugbA3pBQvzX5eRxWXrja/ceCg77X0bLSrK+675mxSln9eX/5qXrNkNcN29WxWln39P/ms+8ODKorxZPWNf+rWVvNdLPm8zEOGW2bkggiiIZzFWMOqvJC3AyEhRchV8J6iv4PsDoK8sVlKSPPqLsu4fyU/fv7rsM9lfGG76h/Nfx9GRstdweKzsdSmJ8yvG87/LAFaPl32HrFJB+sK31ky6IRa3+CmbmbVQRN6WQdJBkq6TdKOkdZaAlXScpGskLZf0E0k7tfz5mJl1oxbG4nZwZdbM6qtFAbRhCcUXALsCh0ratSnZxBKKuwFnkZZQNDMzV2bNzNZDAOOZ28zWLKEYEcPAxBKKj58u4vyIWFHdvZg0/6GZWW9rbSxui7nfZ9bMulZBP62ZVp1pyxKKZma9oO59Zl2ZNbP6yg+gM606k61kCUUzs57gyqyZ2fpoaR+stiyhaGY2981uf9gcrsyaWT0FtV9C0cxszmttLG4LV2bNrL5aNKCgXUsompn1hFkc3JXDlVkzq626L6FoZtYLPADMzGx9BOUrPJmZWWt1QSx2ZdbMaqr+gw7MzOa++sdiV2YbFfyzYrzsH1vcRF+SvjDvvuGyX1iDj+XnP/RwUdasfjR/rexHVswryvv+RQuL0i/oz1+3/YHhBUV5P/JgWVm2vC//NdfKskH342NjRemjMH1L1TyAWoYIGMn/bJW831SQb3qAipJHQfqynEF9hWsW9RekL2xE01D+A/pXl30mS9P3DeenjZGy13D1SFmVZ9XoYHbalWP5aQFW9Zeln9eXn74/2tCKWvNY7MqsmdVXzQOomVlPqHksdmXWzOopgMIrIGZm1mJdEIs7WpmV9FvgEWAMGG1esUfSpsDpwB8Cq4A3RsRVOY81s7kmoB2XywwASf3AMuCOiPjLpmP/DOxf3V0IbBURS6pjJwEvqo59MCK+1ZkSm9nsqH8sno2W2f0j4t4pjv09cHlEvETSLsBngQMyH2tmc03NL211uWOBa4GNmw9ExNsnbkt6K7BHdftFwJ7A7sA84AJJP4iIwt7yZtZVah6LC3ugt92uwHkAEfFrYKmkrWe3SGY2KyYubeVsVkTS9qTW1dMykh8KfKO6vStwYUSMRsRjwHLgoPaU0sxqoQticacrswH8WNKlko6c5PgVwEsBJO0N7ERaQz3nsVSPO1LSMknLRvDS6mZdLSJvs1KfAt7FDOPeJe0E7EzVyECK0QdJWihpC1JXhB0medyaODzsOGzW/WoeizvdzeBPI+IOSVsB50r6dURc2HD8o8CnJV0OXAlcRuojm/NYACLiVOBUgI21mb/lzLqZK6otJ+kvgbsj4lJJ+82Q/BDgrIgYA4iIH0v6E+DnwD3ARTweo9dojMOb9G3uf6JZt6t5LO5oy2xE3FH9vRv4LrB30/GHI+INEbE78DpgS+CmnMea2RwTAWNjeZuV2Bc4uBpU+03geZK+OkXaQ3i8iwEAEfGhiNg9Ig4kTa96fTsLa2azrAticccqs5IWSdpo4jbwF8BVTWmWSBqq7h5B6pv1cM5jzWwOqvmlrW4UEe+JiO0jYimpsnpeRBzWnK4ahLspqfV1Yl+/pM2r27sBuwE/7kjBzWz21DwWd7KbwdbAd5VWVBkAvh4RP5T0ZoCI+DzwFOBMSQFcDbxpusd2sOxmNhtcUe0YSScCyyLi7GrXIcA3I9b6JwwCP61i8cPAYREx2tmSmlnH1TwWd6wyGxE3AX88yf7PN9y+CHhy7mNnk/oKFy/sz1+2tTR9lC6LWKhvJP9NPLCqcKnDVfmv48jqsrfrw6vnF6VfPJg/UOWhwuVsebSs7EOPFszpN1JYl+iay/KeqaDdIuIC4ILq9glNxz4wSfpVpBkN8s8BxFjB+7lgPsuifKH4va/R/PgUKovDGi38HBakL11at28kP+++kbLXvH+47Luvb7ig9KNlr/nwaFlZVo3lx+3V42UxfnWUpR+J/LIPF+Y9s/rHYq8AZmb1FBA1n6jbzGzO64JY7MqsmdVXzVsDzMx6Qs1jsSuzZlZfNe+nZWbWE2oei12ZNbN6ioDxel/aMjOb87ogFrsya2b1VfPWADOznlDzWOzKrJnVVtS8NcDMrBfUPRa7Mmtm9RQBpVMvmZlZa3VBLHZl1szqq+bTwZiZ9YSax2JXZs2slgKImk8HY2Y213VDLHZl1szqKaL2rQFmZnNeF8RiV2bNrLbq3hpgZtYL6h6LFTWfbmFDSLoHuKVp9xbAvbNQnMm4LJNzWSY3F8uyU0RsOdkBST+szpPj3og4qAXlsRabIg7D3Hw/t4LLMjmXZXKtKMuUcRi6IxbP6crsZCQti4i9Zrsc4LJMxWWZnMtic0md3kMuy+Rclsm5LPXTN9sFMDMzMzNbX67MmpmZmVnX6sXK7KmzXYAGLsvkXJbJuSw2l9TpPeSyTM5lmZzLUjM912fWzMzMzOaOXmyZNTMzM7M5wpVZMzMzM+tac7YyK+kgSddJulHSuyc5Pk/St6rjv5C0tMPn30nSTyQtl3SBpO0bjp0k6apqe9UGluN0SXdLumqK45tK+m5Vjl9KelrDsbdLuroqxzckzd/Asuwg6XxJ11T5Hjtb5ZE0v8r/iirPf5wkzaT/I0n7S7q8YVsl6a/XtyxVnv2SLpP037nlqI7tKOnHkq6tXtelG1KOKs/fSrqyem7LJjk+3f9o2sdab8mIP5L0mSpOLpe0ZyfPX6XZr3q/Xi3pf6t9M8aH9ShLTvx7TfU6XCnp55L+uOHYEklnSfp19Xl/VpvLsomk/2p4Dd7QcKyV31E5sfhwSfc0xNwjqv07SfpVw//vzRtSlirP6WLxc6rzjUp6edOxdsTi6cryzw2vx/WSHmw41rL/T9eIiDm3Af3Ab4AnAEPAFcCuTWn+H/D56vYhwLc6fP5/B15f3X4e8JXq9ouAc0mrsy0CLgE23oCyPAfYE7hqiuMfB95f3d4F+El1ezvgZmBBdf/bwOEb+LpsA+xZ3d4IuH6S16Uj5QEELK5uDwK/AJ6Z8z9qSrMZcD+wcANfm+OArwP/PcmxKcsBXAAcWN1evKHlqPL5LbDFNMcn/R/lPNZbb20Z8eeFwA+qz+MzgV90+PxLgGuAHav7W1V/Z4wP61GWnPj3bGDT6vYLGl8P4EzgiOr2ELCkzWX5e+Ck6vaWVZwbovXfUTmx+HDglEkeOwTMq24vruLPthv4f5ouFi8FdgO+DLy86Vg7YvGUZWlK91bg9Op2S/8/3bLN1ZbZvYEbI+KmiBgGvgm8uCnNi0nBAeAs4ABJ6uD5dwXOq26f33B8V+DCiBiNiMeA5cB6r6YREReSgtBU1pQjIn4NLJW0dXVsAFggaQBYCNy5vuWo8r8rIn5V3X4EuJZUSe14eSJ5tLo7WG3NoyGn+h81ejnwg4hYsb5lqVpaXwScNkWSScshaVdgICLOBYiIRzekHAWm+x+ZrZERf14MfLn6PF4MLJG0TQfP/2rgOxFxa5X+7upvTnwoLcuM8S8ifh4RD1R3LwYmrgZtQqqYf7FKNxwRD7azLKTnu1H1vbiY9DqO0vrvqPV+ravXYXV1dx4beLV5plgcEb+NiOXAeNPjWh6LM74XGh0KfKO63dL/T7eYq5XZ7YDbGu7fzrof1DVpImIUeAjYvIPnvwJ4aXX7JaSgsXm1/yBJCyVtAewP7NCick1mTTkk7Q3sBGwfEXcAJwO3AncBD0XEj1t10uoSzB6kX+GzUp7qEs7lwN3AuRExZVlY+3/U6BAeDyLr61PAu2gKkBnleDLwoKTvVJeiPi6pfwPLAumL5MeSLpV05HTlafwfZT7WrFFOrGynJwObKnXfuVTS6yYOZMSH9TZN/Gv0JlKrNcDOwD3Al6rP+mmSFrW5LKcATyE1GlwJHBsR47ThOyrztX5Z1QXjLEk7NDx2B0nLSe+jkyJiQxpdPsX0sXgq7YjFWWWRtBPp/THR4NHpOkQtzNXKbDc4HniupMuA5wJ3AGNVBe0c4OekStJFwFgby/FRUmvI5aRLFZcBY5I2JbWa7AxsCyySdFgrTihpMfAfwNsi4uHZKk9EjEXE7qSK2N5q6PtZmfR/1PA8tgGeDvxofcsg6S+BuyPi0mmSTVWOAeDPquN/QurWcvj6lqXBn0bEnqTLnEdJek7T8Un/R5mPNauTAeAZpBaw5wPvk/RkyIoP62WG+DeRZn9SZfbvGsq5J/C5iNgDeAxYZyxGi8vyfOByUrzdHThF0sbt+I7KeK3/C1gaEbuRLqGf2fDY26r9TwRev75XiTJj8VRaGosLy3IIcFZEjAHMQh2iFuZqZfYO1v4lsn21b9I01WXrTYD7OnX+iLgzIl5aBab3VvserP5+KCJ2j4gDSf2Jrm9RudYREQ9HxBuqQPI6Ut+om4A/B26OiHsiYgT4Dqk/1waRNEgKnl+LiO/Mdnmqcz5Iunx/UNP+Kf9HlVcC363Ks772BQ6W9FtSd5TnSfpqZjluBy6vurOMAt8jfeFtkKoVfOKS63dJ3WYaj0/1P5rxsWZNcmJ1O90O/CgiHouIe4ELgT9uTDBVfFgfM8W/Ks1upEvLL46Iie+k24HbG1osz2IDP+sZZXkDqQtGRMSNpDELu0D7vqOmicX3NXQnOI30A6T5sXcCV5Eqletjxlg8jVbH4pKyrHN1sJN1iLqYq5XZS4AnSdpZ0hDpn312U5qzgddXt18OnBcRrVpBYsbzS9pC0sTr/x7g9Gp//8Sl7Cqo7Qa07PJ+M6URskPV3SNIfW0eJl3Of2Z1qULAAaR+VRtyLpH6fF0bEZ+czfJI2lLSkur2AuBA4NdNaSb9HzVo7Ke0XiLiPRGxfUQsJb1PzouItVqcpynHJaQW0i2r+88jDWZZb5IWSdpo4jbwF6QviMY0k/6Pch5r1uRs4HVKnknqPnRXB8//n8CfShqQtBDYB7g2Jz6Uyox/O5J+qL82ItZUQCLid8Btkv6o2nUAG/BZzykLKeYeUKXfGvgj4KZWf0dlxuLGftQHU8V+SdtXj6G6evenwHXrU46cWDyNlsbi3LJI2gXYlNT6OrGvo3WI2ogajEJrx0YaJXs9aVaB91b7TgQOrm7PJ40SvxH4JfCEDp//5cANVZrTeHxE5nzSh+Aa0gCA3TewHN8g9TEdIf16fBPwZuDN1fFnVWW4jhREN2147D+SgspVwFcmyrgBZflTUp/K5aTLV5dXr1PHy0P6gF9WleUq4ITc/1F1bCmpBamvhe+Z/ahGrRaU48DqOVwJnAEMbWAZnkDqc3UFcHXDe3fG/9FUj/XWu1tG/BHwWVKcvBLYq5Pnr9K8kxRvryJdbp8yPmxgWXLi32nAAw3HlzU8fndgWfX47zXGxjaVZVtSJejK6jU4rNrf6u+onFj8kSqmXEFqud2l2j8R/66o/h7ZovfNfkwei/+keh89RrqSe3XDY1oai2cqS3X/A8BHm9K39P/TLZuXszUzMzOzrjVXuxmYmZmZWQ9wZdbMzMzMupYrs2ZmZmbWtVyZNTMzM7Ou5cqsmZmZmXUtV2bNNpCk30o6frbLYWZm1otcma0pSVtL+rSk30haLekOST+Q9MLZLludSFoqKSTtlZH2vZJ+JukxSZ6TzszMbA5wZbaGJC0FfkVaG/s9pEml/xz4PvD52StZ15tHmuT/U7NcDjOrIUlnSPrvDp9zU0m/l/SHnTyvtYekf5f0jtkuR69xZbae/rX6u1dEfDsirouIayPiFFLFFkhLH0r6rqRHqu07krZvOP4BSVdJen11KfwxSV+SNCTp/0m6TdJ9kj7ZsFzqxGXzD0j6qqRHJf2u+TJ6wbkPqVqXH5H0PUlbNOXzBknXSFol6XpJb28qS0g6sgoQj0m6SVLjsn43V38vqdJeMNWLGhEnRMQnSKvNZJF0gaTPV63kD1TbxxvLWJkv6d8kPSzpdknvbMrnOEnLq+dwh6TTJpZwrI5vIukrku6uXoubJL2t6fip1fFHJP1vTmu0mdXe3wPnRMRvJnb4yly+KkafMs3x50g6u3oNQ9Lh06TdUtK/Vt+Bq6sfGT+RdGBDmjOqfJq33askJwLvlbRJq56jzcyV2ZqRtBlwEPDZiHi0+XhEPFil6yOtK741sH+1bQt8T5IaHrIUeDHwl8BLgVeQ1kP/E+AvgCOAtwIvaTrVcaT1r/cE3g98WNJL1+Pcr6ry/gtgD+BDDc/1b4APAycATwHeAfwd8P+aynJCdb4/Br4FnK60hjnA3tXfg4BtqufYaq8hfVaeBfwtcCTwtqY0byctY7gncBLwMUnPajg+Xj3mqcCrq3L/S8PxfwKeTvo//RHwRtJyuRPrqH8f2K46vgdwIXCe1l6z3My6iKSFpBj8xYZ9S/GVuVZaTFom91hg5Qxp/4MUm98EPJkUb38AbN6U7n9I3zeN21UAEXElcBNwGNY5s72erre1N9IHKYCXzJDuQGAMWNqw7wmkStOfV/c/QPrwbtKQ5izgHhrWjQYuAE5puP9b4Nym850G/F/huVc1nfu9wI0N928FXtt0nrcB1zTcD+AjDfcHgBU8vk740ipN9pruwMvTWz8r7QXA9ZCWfq72/QNwe9Pr9Y2mx90A/MM0+R4ErAb6qvtnA6dPkfZ5wKPAgqb9lwPvmu33rDdvc2UDzgD+u7o9j9Ql6fdVLLsY+NOm9IuAL1efz9+TKp//DZyReb6XA/c3xZdzSD9kF0+SfknD7WnLV8WuzwGfqM5xD6lCNw/4LPDgFDH4AlKl+dPAA9X28YlYVfDaXEC6yvhh4F7gbuDkhpgn4F3Ab0jfU1dOxPWCPM4gxf/Gbek0r/ejwOFTHFtSPf7Pc98j06Q5ger70ltnNrfM1o9mTgKklsw7I+K3Ezsi4ibgTmDXhnS3RsRDDfd/D1wfEcNN+7Zqyv+iSe5P5Jt77luazn3nxHkkbQnsAPxb1ZXhUUmPAh8FmvuOLW84zygpKDeXt50ujipCVS4CtpO0ccO+5U2PWfNcASQ9T9K5VReER0h9d4eAP6iSfA54laQrJJ0s6bkNeT0DWAjc0/RaPY11Xysza42Pka4svZF0NeRK4IdNV0M+ATyXdPXpeaSrR39WcI4/Ay6diC+5V+YKyvca4BFgH1Js/RTwPdIP9L2AM4HTJrnCM9PVqJxzT+QzCjwbOLrK41XVsX8itYAeRfre+Ajp++BFBXkcS4rHX+LxFtLbWD+PVtvBkuavZx4TfgnsLWnBBuZjmVyZrZ8bSL8On7IBeTRWvEYmOTbZvla9F2Y698R5Jv6+Gdi9YXsa6VJ8o3aWt1WmLKOknUiXCK8ldfN4BulLAFKFloj4AbATqdVhC+D7kr5Upekj/eDYvWnbBXhf65+KWW+TtAh4C/B3EfH9iLiWFKt+T6p8IWkx6XP8dxFxbkRcTaqcjTfks0PVp/Oaqs/8K5pOtRPph++EJ5IaNK7d0PJVro6ID0TEDcAnSa2bIxHx6Yi4kdS/U8C+Tae4CzgmIn4dEd8mtcweV3huSFfZToiI66t8zgcOqPI4DjgiIn4YETdHxNeBL+TmAVA1lgwDKyLid9U2Nt1rN5WqoeRwUveAByVdVDUs7DNJ8oMaGxYk/aDp+J3AIKn7nXVA3SoEPS8i7gd+BBxdBcu1NAwauhbYtupfNXHsCaQPzzUtKMozJ7k/EWA3+NwR8XvSB/4PI+LG5q2gnBMtzP0Fjym1T1Nf4GeSWqYfznz8XqRK69sj4qKIuJ5JglxE3BsRX4mIw0lfiq+XNI/Uf25rYHyS1+ruDXliZjapPyRVRn42saOqJDVeoZpI88uGNI9R9Z2sjAJvi4hdSeMGPlVV5CYsIF2mn5B7ZS6nfLD2Va0gXaa/smHfCKkbQfOVrumuRuWee63zVyauWO0KzCe15jZebXoL01yZa8qj5SLiP0ix+a9IfWWfDVws6e+bkl7I2g0LRzQdn+ib65bZDhmY7QLYpI4iBYplkt5H+jCLNNDqPcCOpA7oy4GvSTq2ety/kCo+57WgDM+U9B5SH9v9gNeRLvfQwnO/H/gXSQ+S+okNkgZQbRcRH8nM425S4Hi+pN8Cq5q6NqxRDRrbjNTPlobRpzdOdkmvwbakL6F/JQ3SeifpElmuG0g/HN8m6TukyvDbmsp2Iun1u5r0uXwpcFNErJb0P6T3w39Kehfwa1L3hIOA/4mInxaUxcw2TPYc1RFxF6mVk4j4naR7STHosSrJvcCmDQ9pvDL33RaUbzavzE11/r6G8/0Vqd/udI/p6JW5iFgFnFttJ0o6DfiApJMbuuetmKHRZbPq7z3tKqetzS2zNVT1P92T9GE6iVRxPA84mNR3aeJX9otJH5bzq+13wF83/aJeX58kjaK9jFRxOyEizmrluSPiNNJlutcCVwA/rZ7fzdM9rimPUeAY0i/jO0mzHkzlxOr5fLy6f1m1zTTF1ddILb+/IF0G+yLwzwVlXE7q23UcqeX6CKB5xbDVpJkeriBVXDciBfqJ1/uFpPfAF4DrgG+TZj24EzNrtd+QrvqsufwuqZ/Uh/SahjQjpJlhJtIsJHWVWoekZwD9EdHYp/MyGlozC67M5ZRvQ0x3NaoV576GFPN2muRq0y2FZR2mvVfmriE1MJT0o30acEd1BdI6odUjyrx1/0YanX/8bJejDhtNMz148+Zt7m6sPZvBp0itqi8ktZSeShogtE1D+s9X8fIAUqX068BDwJea8t2MdNXl2U37n06aGWbzhn1PqM77a1If+z8i9Y9/C2lALznlmyx2kbpAfKBp3++AoxvuX0AaNPbp6twvJ818cHzuuac5f+Pr+0/AfaQGjSeSLte/GTgyN4/q/qnApaQrblvQMOtCdXwxj3cHWEGaaWB3YMemdJuTGgwOIzXk7Fy9/r+jYXaf5vNP8z764my/n3tpczcDMzOzdf1d9fdLpGmbLgMOitR1YMLxpOm5ziZV5v6Z1L99TT/Yqt/794CPRsTPG08QEVdK+iVwCGm6LCLiJkl7khZTOIk0v/R9pKs2RxaWb301Xo0K1r0a1Ypzv480aOx40mwuD5OmG/xYYVlPJs3KcA2pj+rOpB8YE/YiXT2c8I/VdiZpwNeER0lTjB1LqlzPI02R9nUKupVVMyG8hDRPsHWIql8RZmtUfU9PiYiTZ7sss01pRbGrIuLo2S6LmdVbVXG9Bfh4RHyiulT/deC6iPjAFI85iNQKumus50j8VnLM2zCSjgJeHBF/Mdtl6SVumbV1RMTS2S5DXUTEfrNdBjOrJ0l7kC6z/5LUz/3vqr/fqpLsS5oTdbmkv672vTbSKlEARMQPJX0W2J5UEbbuNkJaVdM6yJVZMzOz9XccqW/pKOky+XMi4naAiPg/MgZaR8Rn2llA65yIOHW2y9CL3M3AzMzMzLqWp+YyMzMzs67lyqyZmZmZdS1XZs3MzMysa7kya2ZmZmZdy5VZMzMzM+tarsyamZmZWddyZdbMzMzMupYrs2ZmZmbWtVyZNTMzM7Ou5cqsmZmZmXUtV2bNzMzMrGu5MmtmZmZmXcuVWTPrCZJOl3S3pKumOC5Jn5F0o6TlkvbsdBnNzOaydsVhV2bNrFecARw0zfEXAE+qtiOBz3WgTGZmveQM2hCHXZk1s54QERcC90+T5MXAlyO5GFgiaZvOlM7MbO5rVxweaFUB62hwaFHMX7Bp/gMiP6miIHGbhVT2gMLk0Z//gPH+0rzbk3Z90pfQWGH60bL0fePtK0vJ+xwK3+uFeT/68B33RsSWkx17/v6L4r77857cpctXXw2sath1akScWlYatgNua7h/e7XvrsJ8rEH/okUxuGSz9mReGMtK359l3wnty7s4fWmML2jWKkkLQGkcLnkhi7+GC1+Ykjhcp/9/odV33T5lHIaOx+L1isNzujI7f8Gm7Pnst2an7xvJf7f0jRW8y6HoQ5FOUJB1f1l0GZtXln50UX76VZuU5T28JD+4rN607NM8uqh9n/7BR8qC4rz7y9IPPZxf9sHHyp5n/3Bp+vw3r0bL8r7wh+++Zapj990/xi9/tGNWPv3b3LAqIvYqOrl1xOCSzdjxLW/Pf0Dkf1ZioOz9ptGyz2FfwY/Q4h+sI21MX1jhHFlYkHajstd8bKOyL78YKEhf8F6B9fj/r85P3zdSmPdwUfKisquwvnHdB4+bMg5Dd8TiOV2ZNbPuFcB48a/ADXIHsEPD/e2rfWZmPavDsXi94nAt+sxKOkjSddXotXdPcnyepG9Vx38haeksFNPMOigIRmIsa2uRs4HXVaNpnwk8FBE91cXAMz6YWbMOx+L1isOz3jIrqR/4LHAgqW/EJZLOjohrGpK9CXggIp4o6RDgJOBVnS+tmXVSK1sDJH0D2A/YQtLtwPuBQYCI+DxwDvBC4EZgBfCGlp28e5wBnAJ8eYrjjSON9yGNNN6nIyUzs1nTqljcrjg865VZYG/gxoi4CUDSN0mj2Rorsy8GPlDdPgs4RZIiajQKy8xaKgjGWvgRj4hDZzgewFEtO2EXiogLZ7jytWakMXCxpCWStum1FmyzXtLKWNyuOFyHbgZTjVybNE1EjAIPAZtPlpmkIyUtk7RsZPixNhTXzDplnMjarGNy4vVacXjsMcdhs25X91hch5bZlqqmgDgVYKNNtve3nFmXCmDMFdWu1BiH52+3g/+JZl2sG2JxHSqzOSPXJtLcLmkA2AS4rzPFM7PZ4lbX2vGMD2Y9qO6xuA7dDC4BniRpZ0lDwCGk0WyNzgZeX91+OXCe+8uazW0BjEVkbdYxPT/jg1mv6YZYPOstsxExKulo4EektUJOj4irJZ0ILIuIs4EvAl+RdCNpGbRDZq/EZtYpHZ1l1jzjg5lNqu6xeNYrswARcQ4pSDbuO6Hh9irgFZ0ul5nNniBq309rrvGMD2bWrBticS0qs+0yNiQe2X4wO/3givx/1sDqwmUUxwrTF/wMGh8oW0ZvdH5Z+uGN8tOv2qIs71Vb5T/Rvq1WzZyowVabPlKUfvFQ/vqCj6yeV5T3PfdvVJQ+7svPf/Dhstd88LGy3kUDj+Uvrj5Q8BmaUUDhx8ZqKIaC1TsUrN1ZsERp32DZJO0q7Fg3PpL/gFiV/zkB6FtVVpi+4fzXZbxwmd/xxfmv47wlZXF488Uri9IP9OV/J5SGh+HRsirPqpH89KtXl+U9MlL2fhkvST9W9p0woy6IxXO6Mmtm3SsQI7Q4KJuZWZFuiMWuzJpZLQUwXvPWADOzua4bYrErs2ZWW2M1bw0wM+sFdY/FrsyaWS2librrHUDNzOa6bojFrsyaWW2NFwwGMjOz9qh7LHZl1sxqqRtaA8zM5rpuiMWuzJpZLQVirBaLFJqZ9a5uiMWuzJpZbdX90paZWS+oeyx2ZdbMaqkbLm2Zmc113RCLXZk1s5oSY1HvS1tmZnNf/WPxnK7Mjg/Bozvm/5qY92B+2sFHy2YQ7l9dlLxo+dvoK/vFNFa2EivDG+fnP7xJ4czKm+e/MDtudX9R1nttfmtR+ifP/11R+hK/2WarovSXP7h9dtrbHlxSlPdjDy0oSs9D+UtCDz3YuoAXwAhlSz5a/agvmLcofzlbFYSzgYGy5Wyj8FLpyED++2+kr3AJWRUuZzpUUPb+srIMbpT//9l848eK8t56Ydmy4vP7R7PTjhe2Fq4YHSpK/8hw/pflynn5cRJg5XBZ+pHR/PfL2FhrK57dEIvndGXWzLpXRP1bA8zM5rpuiMWuzJpZbZW2vJiZWevVPRa7MmtmtZQGHdS7NcDMbK7rhljsyqyZ1VT9L22Zmc199Y/FrsyaWS0FMF7z1gAzs7muG2KxK7NmVltjNZ+o28ysF9Q9Frsya2a11A1LKJqZzXXdEItdmTWz2hqveT8tM7NeUPdY7MqsmdVSN4ygNTOb67ohFrsya2a1FIiRqPeqM2Zmc103xGJXZs2sliKo/XQwZmZzXTfE4jldmY3BYPX2+WtOjxWsrTyvZJ1sYLBseWr6V+enVdky3IyXLQlNFLxLxgfLCjMwlL+2+ubzy9YE/8P5dxel/5MFv81Ou1lf/vrhAA8tuLko/TMW5Zfl0iVLi/K+5uFtitLf8uCm2WkfvHdxUd7TU+1XnbGZRcDoSH4QUUFA6+8fLyrLyEhZ61LRGvfjhe/V0rd2G+sSUTBSfWy8rCDD42XVjL6C///oeNn/c+Vo2ZffqtH8sq8ueI8DjIyWlX204L07Xvg/mln9Y/GcrsyaWfcK6t8aYGY213VDLHZl1sxqq+6DDszMekHdY3FHSyfpIEnXSbpR0rsnOb6TpJ9IWi7pAknbNxw7SdJV1faqTpbbzDovEOORt1k+SadLulvSVdOk2U/S5ZKulvS/1b75kn4p6Ypq/z92rtRmNlu6IRZ3rDIrqR/4LPACYFfgUEm7NiU7GfhyROwGnAh8pHrsi4A9gd2BfYDjJW3coaKb2SwZoy9rsyJnAAdNdVDSEuBfgYMj4qnAK6pDq4HnRcQfk2LxQZKe2daSmlkt1D0Wd/LMewM3RsRNETEMfBN4cVOaXYHzqtvnNxzfFbgwIkYj4jFgOdMEYzPrfkGaqDtns3wRcSFw/zRJXg18JyJurdLfXf2NiHi0SjNYbYXDT82s23RDLO7kmbcDbmu4f3u1r9EVwEur2y8BNpK0ebX/IEkLJW0B7A/sMNlJJB0paZmkZWOPlo1+N7M6EWOZm7XUk4FNq65el0p63cQBSf2SLgfuBs6NiF9MlsFacfgRx2Gz7lb/WFy3AWDHA6dIOhy4ELgDGIuIH0v6E+DnwD3ARcCkczpFxKnAqQDzlm7vVgOzLjXRGmAdNwA8AzgAWABcJOniiLg+IsaA3auuCN+V9LSIWKfv7Vpx+AnbOQ6bdbFuiMWdrMzewdqtqdtX+9aIiDupWmYlLQZeFhEPVsc+BHyoOvZ14Pr2F9nMZktE/Ved6SRJ84BtSRXMeyLinjad6nbgvqpL12OSLgT+mIaYGxEPSjqf1N1ryoFkZtb9uiEWd7KqfQnwJEk7SxoCDgHObkwgaQtJE2V6D3B6tb+/6m6ApN2A3YAfd6zkZjYrxqIva5urJG0k6S1VhfIh4EZS5fF3km6V9IXqqlUr/Sfwp5IGJC0kDbq9VtKWVYsskhYABwK/bvG5zayG6h6LO3bmiBgFjgZ+BFwLfDsirpZ0oqSDq2T7AddJuh7YmqolljTQ4KeSriFdujqsys/M5qgAxquVZ2ba5iJJxwG/Bd4InEsaELs7qU/rs4APkK6unSvph5KelJnvN0hdtf5I0u2S3iTpzZLeDBAR1wI/JA20/SVwWtWVYBvgfEnLSY0T50bEf7fo6ZpZTbU6FmdM07qjpPMlXVZN1frCmfLsaJ/ZiDgHOKdp3wkNt88CzprkcatIMxqYWc/QnG51zfBM4LmT9Umt/BI4vaqEvgl4LnDDTJlGxKEZaT4OfLxp33Jgj5kea2ZzTeticcM0rQeSujRdIunsiLimIdk/kBo8P1dN4XoOsHS6fOs2AKylBobG2HqbB7PT/348fw36/tVlazwPrCxKnmZ0zFU4vEJly5mjSYfaTa5vtKyVrGTt8+Gxsrdr6QTO8wue6Db9C4vy3n6gLBBs2/+77LTbDTxQlPfS+fcWpb90wU7Zaa8YbJ6gZHq3TnMsDTqYm62uOSLilZnpVpPmha0l9QVD80by0ys/oC0Yys8XYGig7ILe8Gh+zBnpLwusY4NlfRCjIPu+/rIvhY0W539BbbZgRVHem80rm81iXl9+HF45VvY9XKok/kRhrCqNbSWfi9HR1vZvbXEsXjNNK4CkiWlaGyuzAUysJbAJcOdMmWZ/w0raWtLxkj5XTY+FpH0l7Zybh5lZiVZO1N2OS1vtJmm3hnEEZmazooWxOGea1g8Ah0m6ndQq+9aZMs06s6RnANcBryFdzpqoMR/I4/1azcxappVLKGauQDhxaWsP0gDVOrR2XgZsMXFH0vclbTOL5TGzHlMYi7eYmGO62o5cj1MeCpwREdsDLwS+MtOP+txrKCcDn46I90t6pGH/j4A3rEdBzcxmNN66MaptubTVAc019eeQpuYyM+uYglh8b0TsNc3xGadpJTWaHgQQERdJmk/6UX/3VJnmlu4ZwJmT7L+LNOuAmVlLRcBYKGtj5taAtlzaMjOb6wpj8UxmnKaVNJziAABJTwHmkxbMmlJuy+xKYLLRUbswTU3ZzGxDFAw6mKk1IMfEpa1PSHoW6dLW0yJKht60XLDuEE+vqGVmHdWqAWARMSppYprWfuD0iWlagWURcTbwDuALkt5OineHR8S0cS+3MvufwPslvWKiPJKWAicB/1H+dMzMphe0dNWZtlza6gABX5U0Mb/JfFKQX2tIeUQcvM4jzcxaoMWxOGea1muAfUvyzK3MHl+d+B5gIfB/pO4FPyMNmjAza6kWTwez5tIWqRJ7CPDqpjQTl7bOyL201QHN3bu+OiulMLOe1Q3TJGZVZiPiYdLyhs8D9iT1tf1VRPxPOwtnZr1MjLdoou52Xdpqt4jwAFszm2Wti8XtUjQLfUScB5wHIKm9sxWbWc9r5VK17bi0NVskDQDzI+LR2S6Lmc19dV82PHee2WMkvazh/heBldUE5H/UttKZWc9q8QjariTpAEmvbNr3buBR4EFJP5S0ZFYKZ2Y9oRticW7L7DHAGwEkPQd4Jam/2cuATwB/2ZbSbaChvlF23Dh/qc/7H85fonR8XuFKwIX/5P6CVRr7RsquhEbZCpBFRR+bX/Y8Vz48lJ32jo03Kcr7mkXbFqX/g8GHstMOkr/cLMCW/e1bOXrL/rK1kp88VFb2FYvy/0cPDJct83vJDMfrfmmrA94N/GDijqS9gQ8DXwSuBd4JvLf6W0uD/eNsvckjMyesDPTlTx7RX7g2d0neACNj+YNeVo6WXawcGS97bw8WlH3J/LKYsOPC/O/JP1pYFj+2HSxbbrvkf/rw2PyivO8d3XjmRA1+P5Kf/v7hRUV5PzBcNl30itH8OFz6XrwxI03dY3HuN+x2wM3V7b8C/j0ivi3pSuCnbSmZmfW0iVVnetzTSRXaCa8Afh4RfwMg6Tbgn6hxZdbMuls3xOLcqvbDwFbV7QOBn1S3R0gjfs3MWm4cZW1z2BLWnhpsX+CHDfcvYd3FH8zMWqrusTi3ZfbHpFG+vwKeyOOXvZ7K4y22ZmYt0w3TwXTAXcAfArdJmgfsAbyv4fhGwOrJHmhm1grdEItzK7NHAR8CdgReHhH3V/v3BL7RjoKZmdW9n1YH/AD4WDXo62DgMdbu2rUbeV3ezMzWW91jcck8s+usUx4R7295iczMgAgxWvMA2gEnAN8B/oc0g8HrI2K44fgbgXNno2Bm1hu6IRYXD7GW9AfAWsPqIuLWlpXIzKxS90tb7RYR9wLPkbQJ8GhEjDUleQWpkmtm1jZ1j8VZldkqkH6GNCXXZPNDtG7RXjMzuqOfVqdExKTzxjV0+TIza4tuiMW57cYnA38M/DWwijTH7DuB24FXtaVkZtbzxkNZm5mZtU/dY3FuN4MXAIdGxE8ljQGXRsS3JN0F/C1wVttKaGY9qRvmNjQzm+u6IRbntswuAW6pbj8EbF7dvgh4dovLZGYG1H9uw06QtETSiyQ9W5Kaji2SdMJslc3MekPdY3FuZfY3wBOq29cCh1RB9aWA+2yZWetF/S9ttZukp5Ji7n8C/wdcImmnhiSLAc8qY2bt0wWxOLebwRmk+QwvAD4K/DdwNKkyfGw7CtYKgRgey5+wIQrWyu5rHlM8g4FVUZR+6NGC9clXla03XvrjqX+4feP7oj///3Nv/yZFeV+spUXpV47lr3192+LNZ07UoHR98kV9+fPgr4qydbjvG11clP6h0YXZaUs+bzPphkEHHfAR0hWw1wIbA58GfiZp/4i4YVZLlqlf42wytCo7/fyBkey0pe+PAZXFyr6h/Li9YrTsczg8XvZZWTK0MjvtLot/V5T3bgvyJyR6+tDdMydqsP3AgqL0g8r/vnlo/J6ivO8cLfsevmV00+y0vx3eoijvu0aWFKW/bzg/bj88Oq8o75l0QyzOnWf2nxtunydpF2Av4IaIuLJdhTOz3lb3ANoBzwT2j4jHSAsmvFLSJ4ELJO1P6vZlZtZWdY/F69WMUs0r67llzaxtumHQQQfMIzWMrBERx1XdvC4gzSxjZtY23RCLsyuzkvYBDgC2oqmvbUQck/H404G/BO6OiKdNcnxT4HTSOuSrgDdGxFXVsbcDR5CC+pXAGyIi/7qVmXWlqHkA7YDrSFfBrmncGRFvl9RH6ktbRNIOwJeBrUkx9dSI+HRTmtcAf0fqlPQI8JaIuKI6tgQ4DXha9fg3RsRFpeUws+5R91ic1UlU0vGkfluHA7sDT2/Y1qmYTuEM4KBpjv89cHlE7Aa8jtQ3DEnbAccAe1WV4H7gkMxzmlmXioDR6Mva5rDvAodOdiAijgW+SnEveEaBd0TErqRuDEdJ2rUpzc3AcyPi6cAHgVMbjn0a+GFE7EKaf/zawvObWRfphlic2zJ7LHBMRJyyvieKiAulaUfk7EoaXEZE/FrSUklbN5RzgaQRYCFw5/qWw8y6R91bA9otIj5CGgQ21fGjgKMK87wLuKu6/Yika4HtaGj9jYifNzzkYmB7WLMa5HNIDRtExDAwXHJ+M+s+dY/FudXojYFz2lkQ4ArSVF9I2hvYCdg+Iu4grUB2KykAPxQRP54qE0lHSlomadnwg/mjP82sbvKmgql7X646qxoY9gB+MU2yNwE/qG7vDNwDfEnSZZJOk7Roknwdh83mjPrH4tzK7DeYvotAK3wUWCLpcuCtwGXAWNWX9sWkILotsEjSYVNlEhGnRsReEbHX0JKyKUHMrF4ilLVZOUmLgf8A3hYRD0+RZn9SZfbvql0DwJ7A5yJiD9IMC+9ufpzjsNncUvdYPGU3A0nHNdy9DfhHSfsCy4G1JgKMiE9uaEGqYPqG6twi9dm6CXg+cHNE3FMd+w5p1bGvbug5zay+umFuw06RtCNwW0RE034BO1QzzJTkN0iqyH4tIr4zRZrdSAO9XhAR91W7bwduj4iJltyzmKQya2ZzRzfE4un6zL616f6jpEpk8/K1AWxwZbYaIbui6oN1BHBhRDws6VbgmZIWAitJMyos29DzmVnNRRp4YED6cb8N0Dxj/WbVseyZ5qsK8BeBa6dqiKgqz98BXhsR10/sj4jfSbpN0h9FxHWkeHzNZHmY2RzRBbF4yspsROzcyhNJ+gawH7CFpNtJSzAOVuf6PPAU4ExJAVxNurRFRPxC0lnAr0ijcC9j7ZG1ZjZHzeZa3zUjmuabrSwmTWVYYl/SimJXVt26IM0msyOsiccnAJsD/5rqvoxGxF5V2rcCX5M0RLp69obC85tZl6l7LC5eNKHqZ0VEPFryuIiYdHqZhuMXAU+e4tj78frjZj0lqP8I2naT9JnqZgAfkbSi4XA/sDdweUmeEfF/zDCdV0QcQbpCNtmxy0lz35pZD+iGWFyyaMLbgONIU7gg6U5S94JPNffjqovVowPc/MBm2elHHx7KTrvokbJ/7NDDZWuCDz04mp22f2V+2vUxsCJ/rez+4bLfR/3D+Xn3rS5b+/zeFZsXpb/goXUGZU/pqk3/oCjvzResmDlRg8WDq7PT9k3aYDe1VWNl/6PHRvLX+f7dIxsV5T09z1RAmssbUuXzKaw9DdYw6YrVyZ0uVInhsQFueTB/jfv5QyMzJ6qMjZfNa9mnss/KQF9+3B4rfK+OjuXHPoDVC/I/t9vML1vluF/5z7O/8CPZV6MWvZHsMe/Jw+Pzs9PeP7q4KO/frd64KP09q/Lzf2Qkv9x56h+Lsz4dkj4GHAl8nLR4AsCzSJeitgHe1ZbSmVlPq+fP5M6JiP0BJH0JOHaqWQfMzNqp7rE496feEcAREXFWw77zJF0H/BuuzJpZi0XAeGHL21wVEe6Xamazohticcn1xuVT7Kv3MzSzrlX3S1udJOlVpNkDtqIp7kbEwbNSKDPrCXWPxbkV0S8z+ZKJbwG+0rrimJk9LiJvm+skfZw0t/ZS4EHgvqbNzKxt6h6Lc1tm5wGvlvR80jrdAPuQVuT6WsOIWyLimNYW0cx6Vd1H0HbQ64BDm7p6mZl1RN1jcW5ldhfSqFmAnaq/v6u2pzSk64E2EjPrhMBL1Tboo3AKLjOzVuiGWJxVmZ0YUWtm1kn+dbzGqcBhwAdmuRxm1oPqHouLF00wM+uIqP+lrQ5aQurqdSBp4O1ak7G6e5eZtU0XxGJXZs2svureHNA5u/J4N4Ndmo75VTKz9qp5lHFl1sxqq+6tAZ3irl5mNpvqHovndGV2fHU/j92wJDv9wgfy/1kL7yr7mbLg3vwlGgGG7stf/lQrh2dO1Kh0/ozB/LfJwCP5SwIDDD2Un37eQ2XL2c6/v2wK5FWbL8xOe+/GC4ry/v3CsuWMY6jgf1S4RCeFQUmj+en7VrZ22ulemHZrrhtf0c+K5fnL2T5W8K2ksbKyROHbMwrKEn1lb1aNl30O71uQH0Nu3Sr/9Qa44Q+2yk77tE3uLMp7m6EHi9L3k/88HxrLj9kAt63KX94e4LeP5ae/8+Gy5WkfebTsO2R0Rf6bUavLlkrOUfdY7AUPzKyWIiDG+7K2XiDpBZK+L+laSTtU+46QdMBsl83M5q5Wx2JJB0m6TtKNkt49RZpXSrpG0tWSvj5Tnhv0LSCpT9KOG5KHmdlU6j5Rd6dIeg3wbeB60sIJE5cp+vFy4mbWZq2KxZL6gc8CLyCNBThU0q5NaZ4EvAfYNyKeCrxtpnynrcxKmi/p85LukXS9pGObkmwJ3Dxz8c3M1kNkbnPfu4C/iYi3A6MN+y8Gdp+VEplZ72hdLN4buDEiboqIYeCbwIub0vwN8NmIeAAgIu6eKdOZOmGcAPxl9XcT4B8k/QnwuoiY6NhS717BZtal6j9Rdwc9Cbhokv2PAmWd9czMihTF4i0kLWu4f2pEnNpwfzvgtob7t5NWlG30ZABJPyNdffpARPxwupPOVJl9Fak14AdVxt8AfgB8XdKrqzS90S5iZp3Xwugi6SDg06TgeFpEfHSSNK8kLUwQwBUR8ermNLPkTlKAv6Vp/3OA33S+OGbWU/Jj8b0RsdcGnm2A9AN+P2B74EJJT4+IB6d6wEx9ZrcBrp24ExG3APsDTyc1DZcNLzczy1VN1J2zzaRd/bQ66FTgM5L2re7vIOn1wMeAz81escxszmthLAbuAHZouL99ta/R7cDZETESETeTxgo8abpMZ6rM3gU8ca3nFPF74ABShfbLM5fbzGw91byfVqdExMeA7wDnAouA84HPA5+PiM/OZtnMrAe0LhZfAjxJ0s6ShoBDgLOb0nyP1CqLpC1IV6Vumi7TmSqz5wPrXGaLiN8BzyPVqM3M2kSZW+qn1bAd2ZTRZP20tmtK82TgyZJ+JuniqltCbUTEe4EtSBXzZwJbRsT7ZrdUZtYbsmPxtCJiFDga+BHpyv+3I+JqSSdKOrhK9iPgPknXkOqh74yI+6bLd6Y+sx9k3aUTJwp0l6TnAn8xY+nNzNZHzftpdZKkV5Guim1F1RAhpS+PiDh46keamW2gFo5fiIhzgHOa9p3QcDuA46oty7SV2aqPbPOAg8bjdwFn5p7MzKxI6wJobj+tX0TECHCzpIl+Wpe0rBTrSdLHSX14zycNBvPAWzPrnJpHnDm9nK2ZdbGAKFzycxpr+mmRKrGHsG4Xqu8BhwJfyu2n1UGvAw6NiLNmuyBm1mNaG4vbYk5XZgdWwmZX5acfXJG/0Pe8B0ZnTtRg6L6VRen7Hl6Rn3jlqqK8o3DJJPXlLxTXv2KoKO++x+bl5/3Y/KK8hx4qK8vCu/M/DiMLyz7Yo/PLFtsbLyh69JWVReNl//++grd633BR1jOvuNKi1oCIGJU00U+rHzh9op8WsCwizq6O/UXVT2uMjH5aHdQHXD7bhVgfg48G2/10JDv9eH/++1mF74/SaYujoCztnnF9bCj/BKs2XVSU9/V/8IfZaa/cfOeivMcX5n+vAtBf8E8dLYurfSvK0g8+mv+al6QFWPxYUXIGVua/Lv2ryz4YU15+b+SWWTOz9dTCRRPa0U+rg04FDiPNgWtm1lk1X8DGlVkzq63Slrc5bAnwakkHAsuBtZo6I+KY2SiUmfWGusfirDZ3SedJWjLJ/o0lnZeZxw6Szpd0jaSrJR07SZpNJX1X0nJJv5T0tIZjb68ed5Wkb0gqu+ZsZt0ld17DmgfZFtmV1M1gmDTDzNMbtqdN/bB1ZcbiTST9l6QrqjRvaDh2UhWHr6pmWDCzuawLYnFuy+x+wGS9+OYDf5aZxyjwjoj4laSNgEslnRsR1zSk+Xvg8oh4iaRdSCv2HCBpO+AYYNeIWCnp26QBHGdkntvMuo5qf2mrUyJi/xZmlxOLjwKuiYi/krQlcJ2krwEHAnsCuwPzgAsk/SAiHm5h+cysVuofi6etzEras+HubpLub7jfDzyfdae3mVQ1jddd1e1HJF1LmrS8MYDuCny0SvNrSUslbd1Q1gWSRoCFpOlpzGwu641W147KjMUBbKQ0ke1i4H5SJXhX4MJq4vNRScuBg4Bvd/ApmFmn1TwWz9Qyu4zHG49/PMnxlcBbS08qaSmwB/CLpkNXAC8Ffippb2AnYPuIuFTSycCt1Tl/HBGTlYdq5Z8jAYYWbVpaNDOrk5oH0E6qftgfRapQBqny+a/VEuPrm+dSJo/Fp5CWmLwT2Ah4VUSMS7oCeL+kT5AaFfZn7UrwRL5r4vC8+UvWt3hmVhc1j8Uz9ZndGfhD0qQje1f3J7btgI0j4vSSE0paDPwH8LZJLk19FFgi6XJSJfkyYEzSpqR11HcGtgUWSTpssvwj4tSI2Csi9hqYXzY9iZnVTM37aXWKpH2BG0lz464EVgGvAW6Q9Kz1zHO6WPx8Uh/dbUldCk6RtHHViHAO8HPgG8BFpGnM1tIYhweHHIfNul7NY3HOCmCQOVBsJpIGScHzaxHxnUnO9zDwhiqtSNNQ3kQKrDdHxD3Vse8Azwa+2opymVkNBbXvp9VBJ5Mqj2+OiHEASX3A54FPkOJhtpliMSkOf7SaruxGSTeTBp79MiI+BHyoyufrwPXr95TMrCt0QSzOnppL0vbAc2hYF3xCRHwy4/ECvghcO1X6asaEFRExDBxB6pv1sKRbgWdKWkhqlTiA1AXCzOYwjc92CWpjd+DwiYosQHXZ/5OkK1jZcmIxqUvXAaQuX1sDfwTcJKkfWBIR90naDdiNybugmdkcUvdYnFWZlfQa4HTSAIB7WLsxOYAZK7PAvsBrgSurbgSQZi/YESAiPg88BThTUgBXA2+qjv1C0lnAr6oyXEaaRNzMrBc8ROpmdV3T/p2BBwvzyonFHwTOkHQlqZvZ30XEvdWUiD9N9WEeBg6rBoOZmc2a3JbZE0mXst4XEYVr0yUR8X/MsOBfRFxEWg99smPvB95fcs7+VeMsuSF/Wdi+kfyfHlqZvzwjQN9jZcvZxqP55Y5VZcvZMl72EysKlrPVqtVFeZekH1hZlnf/I/lL5QIMzc9fQzbm9RflPT5Ylj4G8i/plC5nW9qvqW+s4HNR8BnKyq8H+sNm+ibwRUnvIvVXhVQpPYnU/SBbZiy+E/iLSfavIg1Ay9a3coQF19yV/4CBgs9K4dLcxVSjS6sFcXjjBWWxb2yj/PSjiwbL8i5dynug4PumMNz0jZRVX/pX5afvW12Wd99w2W9AFZRdo61vRq17LM6tzG4NnLa+FVkzs/VS835aHfQuUgX0dB6P2yPA54B3z1ahzKxH1DwW51ZmzwH2IQ3GMjNrvx6ZqSBHNY7gWEnvIc0wA/CbiMi/hGNmtj66IBbnVmbPBU6S9FTgStZdF3yy0bBmZhum5gG00yJiRTWzAK7ImlnH1DwW51Zm/636+/eTHAvSamBmZi1V935anSTpbcBxpDm+kXQnafDtp6optMzM2qLusTirMhsRLZln1sysSM0DaKdI+hhpRa2PkxYqAHgWcAKwDalPrZlZe9Q8FmfPM2tm1nE1D6AddARwRESc1bDvPEnXka6cuTJrZu1T81ic1eKq5P9JulrSCklPqPa/W9Ir21tEM+tFivytRyyfYp+vnJlZ23RDLM4NgscC/0BaqKBxfoY7gKNbXSgzMwDGlbfNfV8Gjppk/1uAr3S4LGbWa2oei3O7GbwZ+JuI+L6kf2rY/yvgqa0vlplZT7W6zmQe8GpJzwcurvbtA2wLfE3SZyYSRsQxs1A+M5vD6h6LcyuzOwFXTbJ/BFjQuuKYmTWoeQDtoF1IjQeQ4jHA76rtKQ3p/IqZWevVPLLkVmZvAvYEbmna/0LgmpaWyMwMoLf6w04rIvaf7TKYWY/qglicW5k9GThF0kJSn9lnSXotaQTtG9tVuA2l0TEG7nmkKH22kbJ1lWP1cFF6Vq/Oz3u4MO+xNq5KPFA2QUaM5r+OGhmZOVFj+lX5ryFA/7yhgsRlUytHyXrzAP0FY3ravX78WME63+MtXhO85gHUMoyOMn7vffnpCz9bXat0auCCz7kGy+Jw/7x52WkHBgeL8i6KZdDeeFb6mpfUCQq/V0u++9IDCsreju/4msfi3HlmvyRpAPgwsJA04OBO4JiI+FYby2dmvazmAbSTJG0N7AtsRdPg3Yj411kplJn1hprH4uyfbxHxBeALkrYA+iLi7vYVy8ys/pe2OkXSYcBppCtjD7D2V0sArsyaWdvUPRYXL5oQEfe2oyBmZjalDwEfA06MiMLrk2Zmc1tWZVbSZqRgegCTX+LauPVFM7OeV/PWgA7aGDjDFVkzmxU1j8W5LbNfBPYgLZpwJ7V/WmbW9bpgBG0HfQ14EfAvs10QM+sxXRCLcyuzBwAHRsQv2lkYM7O1tHhyhC52HPA9SQcAV5Lm+F4jIk6clVKZWW+oeSzOrczeDTzazoKYmTUS9W8N6KC/BQ4C7gWeyLoDwFyZNbO26IZYnFuZfS9woqTXR4QrtWbWGTUPoB30PuAdEfHPs10QM+tBNY/FuZXZfwCWAndLuoV1L3Ht1uJymVmv64J+Wh3UD5w924Uwsx7UBbE4tzJ7VltLYWY2mZoH0A76EvAa3J3AzGZDzWNx7gpg/9jugpiZraPmAbSDFgJHSHo+sJx1r44dMyulMrPeUPNYXLRogqTnAbuSntbVEXFBOwrVMmPj8HB+F98oWc+4ZL16aO+6zaV5t2Pd5om8x8ve8Sp5HUvLPVI4Jefq4fy0peuNF643r5L1ydu5ljkUrQkepWufz6Dul7Y66CnAZdXtXZqO1fpVigjGV6/Of4DyP1vqK3vvl8anbqXRsvWQNDwyc6JKtDOWART+T4sU/v+LvisLY1/x93BJ2aP1Uw/UPRbnLpqwHfBd4BmkeWYBtpW0DHhJRNw55YPNzNZXzQNop0TE/rNdBjPrYTWPxbk/gT8DjAFPjIgdImIH4EnVvs+0q3Bm1sOiYOsBkraWdKKksyT9u6QPSNpqtstlZnNci2OxpIMkXSfpRknvnibdyySFpL1myjO3MnsgcFRE3DyxIyJuAo6pjs1I0nxJv5R0haSrJa3TD1fSTpJ+Imm5pAskbV/t31/S5Q3bKkl/nVl2M+tSirxtrpO0L3Aj8GpgJbAKOAy4UdKzCvPKicWHS7qnIeYeUe3fSdKvqn1XS3rzhj87M6u7VsViSf3AZ4EXkLqtHipp10nSbQQcC2Qt1lXSsWayYpZ8jawGnhcRj0oaBP5P0g8i4uKGNCcDX46IM6v+uR8BXhsR5wO7A0jajBTUf1xwbjPrRj1QUc10MvAN4M0RqUOcpD7g88AngGcX5JUTiwG+FRFHN+27C3hWRKyWtBi4StLZ7mpmNse1LhbvDdxYNYgi6ZvAi4FrmtJ9EDgJeGdOprktsz8B/kXSDhM7JO0IfKo6NqNIJkZjDVZb88uzK3Bedft80hNs9nLgBxGxIrPsZtalNJ639YDdgU9MVGQBqtufBPYoySgzFk/12OGImBjNNY/87xAz62IFsXgLScsatiObstoOuK3h/u3VvsfPJe0J7BAR388tX24gOgZYBNwk6ZZq4YTfVPuyp4SR1C/pctLyuOdGRHPz8RXAS6vbLwE2krR5U5pDSC0UU53jyIkXcXh8ZW7RzKxu3Ge20UPAzpPs3xl4sDSzjFgM8LKqy9dZTQ0ZO0haTvpCOmmyVtnGODxCwUwGZlY/ZbH43ojYq2E7teRU1RWnTwLvKHlcVmU2Im4D9gReSLrcdTLwgojYMyJuzz1ZRIxFxO7A9sDekp7WlOR44LmSLgOeC9xBGmQGgKRtgKcDP5rmHKdOvIhDfQtyi2ZmNaOCrQd8E/iipNdI2rnaDgNOY5of91PJiMX/BSytVnc8Fziz4bG3VfufCLxe0taT5L8mDg8yr7R4ZlYjLY7FdwA7NNzfvto3YSPgacAFkn4LPBM4e6ZBYNl9ZiNNIHlutW2QiHhQ0vnAQcBVDfvvpGqZrfpjvSwiHmx46CuB70ZE/qR4Zta9eqPVNce7SN8Vp/N43B4BPgdMORp4JtPE4vsakp0GfGySx94p6Srgz/AqkWZzW+ti8SXAkyTtTKrEHkIa2JpOE/EQsMXEfUkXAMdHxLLpMs3u7yTpryVdKOneavuppJcUPH5LSUuq2wtIsyD8uinNFlUTM8B7SIG70aGsRyuEmXWnVs5m0I7pYDql6qt6LLApqf/s7sBmEfH2iChY7SM7Fm/TcPdg4Npq//bVY5C0KfCnwHXr8ZTMrIu0KhZHxChwNOkK+7XAtyPiaqVpBw9e3/LlLprwDuDDwJeBM6rdzwK+Lul9EXFyRjbbAGdW0zL0kZ7Af0s6EVgWEWcD+wEfkRTAhcBRDWVYSmqa/t+cMpvZHNCi1oCG6WAOJA04uKQahX9NU7qi6WA6rRr4euUGZpMTi4+pvlhGgfuBw6vHPgX4RBWjBZwcERtaHjOruxZeJYuIc4BzmvadMEXa/XLyzO1mcDxwdER8oWHf6ZJ+CZxI6kM7rYhYziSjbhufQEScxRSXqyLitzSNeJtRjMPKVfnJ27h0HeNlQ66jYJnX4iUaW7zk6Np5Fy6tW5S49DUsK4tKlmksXqKxcNB3Sf7tXP6xVKuXC635dDDtJukFpK4Eu0XEw03HNiENmv2biMju/pUZi99DujrWnOZcYLfsJ/D4AwsSF8S+9q3M3X6lcbgkJpQucV5SjNLvstLY105t/B4u/n4q/t4uKUsbvuNr3uUr9122mDRVVrPzq2NmZq2VeVmrurQ1K9PBdMDRwMebK7Kwpm/ZScDbOl0oM+shZbF4VuS2zH6PNL/rR5v2vww4u5UFMjNbIz843hsR693HtWE6mMPXN4822Q04bprj5wHv7VBZzKxX1bxlNrcyeyPwbkn7AxdV+55ZbZ+UtCbYRsQnW1tEM+tVLfylXzIdDMAfkKaDOXimUbRttiXTX3cPoHkubjOzlqr7suG5ldnDgQeAJ1fbhAeANzTcD1LrhpnZBmvh6l5tmQ6mA24ntc7eMMXx3Vi7Um5m1nJ1X2kxqzIbEZOtPGNm1j4tXN0rIkYlTUwH0w+cPjEdDI+P4K+j7wMflHRORKy1pKGkhaQBuHXq42tmc00XrLSYvWiCmVnH1Xw6mA74EGm8wvWSTuHx+WCfQhocJtK0iWZm7TNXKrPVAgn7A1vRNAtCRLyyxeUysx4n6t9Pq90i4m5JzyZNz/VhHl8xMkitzEdFxO9nq3xmNvd1QyzOXTThE8BbgZ8Bvwe6eXY/M+sWNQ+gnRARtwAvrFbceiLpu+WGiHhgdktmZj2j5rE4t2X29cArIuI/21kYM7NGaucCHzUnaeeIuHniflV5vWSKtAK2j4jbJjtuZrYh6h6LcxdNWEHT2t1mZm0VBdvcdJGkL0p61lQJJG0q6S2klcxe3LmimVnP6IJYnNsy+1HgXZL+NiJG21kgM7MJde+n1Wa7kBZE+L6kceBS4E5gFbApsCtpINgvgbdFxI9mq6BmNrfVPRbnVma/APwVcIek64GRxoMR8bxWF6wlAqJkjeo6NaP35a/DLfqLsi5+loVrTreNCtf4Llz7Ogq6gqtknXQofm9FSf7RvWufz6hGH8lOi4gHgXdKOgF4EfCnwE7AAuBe4EzgRxFx1awVsh1KP+d1URonS2NIt74u7VQYb6L0O77gfxqF3zfF75fZrp/UPBbnVmY/TwqkPyQNAKv50zKzuaDurQGdUM0ve1a1mZl1XN1jcW5l9lXASyLi3HYWxsxsjaj/qjNmZnNeF8Ti3OsW9+AlE82s02o+6GA2SFogabtJ9j91NspjZj2g5rE4tzL7fuBESYvbWRgzswkTE3XnbL1C0suBG0iDwpZL2qfh8FdmqVhmNod1QyzO7WbwTmAp8HtJt7LuALDdWlwuM7PZH/RQP/8APCMifi/pGcCZkj4cEV/n8dXBzMxaq+axOLcy64EHZtZxvdTqmmlwYvnaiLhU0nOA70p6Ij3X4cLMOqXusTirMhsR/9jugpiZraUH+8NmuFvSbhGxHCAi7pd0IGmaLl8hM7PW64JYnNsyC4Ck55Em6g7g6oi4oB2FMjOD+o+gnQWvBdZauCYihoFDJZ0yO0Uys7mu7rE4qzJbjZz9LvAM0go0ANtKWkaasuvOKR9sZra+at4a0GkRcfs0x37WybKYWQ+peSzObZn9DDAGPDEibgaQ9ATgq9Wxl7eneGbWy+reT6tTJJ0+xaEgLW97I/AtNyyYWTvUPRbnVmYPBPabqMgCRMRNko4BftKWkplZbwtqP4K2g7YE/gwYByaWr30aaQaDS4GXkqZP/LOIuHxWSmj2/9m78zDLivr+4+9PL7MxwACDBBlkcCE4UQREQFHZRMclEI0LKCoq4acRQREXYkQkcUFwDUSDiOCuIWqIokAEggsog8AAwyrrsA37MHsv398fdXq4c+nlVPddzu3+vJ7nPH3vOXXr1N2+t7qqTpVNTh0Qi3PGzA73TKr97ATq7m5K1tlrPGeWQ41e474278gaKp29/nWWroz1xnPXMq+SnOeZSc1+Xboy8m9wWao+TquFfg+sAN4TEasAJM0CvglcA7wG+A7wRWD/dhVyRF3l45+yPm/N+15liwrFp9zfm5zvbW4sy40JTfxN0MBAVvrI+nzl5d1pqh6Ly75TvwH+TdK2QzskPQP4Cm6ZNbMm6ISJulvoaODEoYosQHH7M8CHiovATgJ2bk/xzGyy6oRYXLYyexSwEXCbpDsl3Qn8pdh3VLMKZ2ZTWET5bfKbDWw9zP6/Ko4BLCdzhhozszF1QCwuVZmNiLuBXUldWacU26sjYtfRrq4djqRuSVdJ+sUwx7aT9JtimcZLJM2rOfYMSRdIukHSEknzc85rZp2n6q0BLfQz4FuS3iRpfrG9CfgW8NMize7AzWUzHCMWv1zSnyX1F0vo1h5zLDabYqoei0v/Fx9pkOiFxTYRRwM3AJsMc+wU4DsRcXYxp+3nSPMqQhoP9pmIuFDSbNKFEGY2mU2NimoZ7wW+RJpBZihu9wNnAscW928A/iEjz9Fi8V3AYTV513IsNptqKh6LR22ZlfRqSXdIekqwk7RpceyAsicrWlpfC5wxQpIFwEXF7YuBg4rHLQB6IuJCgIhYUTt2zMwmp6q3BrRKRKyKiPcCmwO7FNvmEfG+iFhZpLm67EwGY8XiiLijWGVssO5xjsVmU1DVY/FYwwyOBE6OiOX1ByLicdIFBx/MON9XgI8y8n/y15CmmAF4PbCxpC2AHYDHJP206BY7WdKwl2tKOkLSIkmL1g2uySiamVVKAINRbpsiImJlRCwutpUTyOorjB6LR1IqFtfG4T7WTqCYZtZ2HRCLx6rM7gT87yjHLwJeUOZEkl4HLIuIK0dJdiywt6SrgL2Be0jzXfSQ5lg8FngR8ExSF9hTRMTpEbFbROw2rWtGmaKZWVVFyW0KkLSVpBMlnSPpPyV9WtJW48inTCweSalYXBuHe5k+jtOYWaVUPBaPVZndktH/cw9gi5Ln2gs4UNIdwI+A/SR9b4PMIu6NiDdExC7AJ4p9jwFLgasj4raI6Ad+Trogzcwmsap3bbWKpL1Iq3y9FVhNWvXrbcAtkl6cmd2YsXgUjsVmU1DVY/FYldmlpNbZkexEaj0dU0QcFxHzImI+cDBwUUQcWptG0lxp/SzFx5EubgC4Apgjacvi/n7AkjLnNbMOVvHpYFroFOCHwA4R8faIeDupy/9HpIUSSisTi0fhWGw2FVU8Fo9Vmf0l8C+SZtYfKFafObFIM25Ft9mBxd19gJsk3QxsRZoQnIgYIHVr/UbStaQ5fL85kfOaWcVFWnWmzDYF7Ax8MSLWP9vi9pdIF4NNWG0slvQiSUuBNwH/Ien64pyOxWZTTQfE4rGm5voM8EbgZkmnAjcW+59LujhMwGdzTxoRlwCXFLePr9l/DnDOCI+5kNFbiZ9KXTCzOeNmK7RwYdM1dbnUnLxzlybO/S8xY9neaOYSv9DcgfQ5y4U22+MjH0qrzkyJVtcyHge2B26q27898Nh4Mx0lFl8BzBvhMXmxWMpaVlzdFVqiNkteuXOXRM+Kw7mxMmMJ2ezfg2bGm8yyZEeTjPdImcsZx2Du5zzjN6fBcbMTYvGoldmIWCbpJcDXSZXWoXcrgPOB90fEA80toplNWVOj1bWMH5EWTfgo8Idi316kGWV+2LZSmdnUUPFYPOaiCRFxJ/AaSZsBzyZVaG+JiEebXTgzm9qq3hrQQh8lxd4zSXFbwDpSQ8PH21guM5sCqh6Lc1YAe5Q0+N/MrPmm0LRbY4mIdcDRko4DnlXs/osXLDCzpuuAWFy6Mmtm1lpTZqaCYUk6t0QaACLiwDGSmpmNU/VjsSuzZlZZU2EO2VE83O4CmJlBY2OxpIXAV4Fu4IyI+Hzd8WOAw4F+4EHg3cWQ1xG5Mmtm1VXx1oBmioh3tbsMZmZAw2Jxsfz1acABpLUMrpB0bkTUzld9FbBbRKyS9D7gC8BbRsu3U+dAMbPJrgPmNjQzm/QaG4t3B24tVhFcR5qp5aANThdxcc31AJczwjSBtdwya2bVNYVbZs3MKqN8LJ4raVHN/dMj4vSa+9sAd9fcXwrsMUp+7wF+NdZJXZk1s8pSMxePMDOzUjJi8UMRsVtDzikdCuwG7D1WWldmzay63DJrZtZ+jYvF9wDb1tyfV+zbgKRXAJ8A9o6ItWNl6sqsmVVTUPlVZ8zMJr3GxuIrgOdI2p5UiT0YeGttAkm7AP8BLIyIZWUyndyV2e4utNGs8umr1AqUseZ05K5lnrEON0D0lF/nO3oy8+5tXt651DdQPu3a8mkBNJCXnv6M9E3+3Larq19E5VedsbEJUE6M6i4fE3JjWVMN5v3al4/w+ZTzGgJ0ZZRGma957u9Tjsz4kP2aZ+SfG6lE3m9CDGa8jrlPdIyiNDIWR0S/pCOB80lTc50ZEddLOhFYFBHnAicDs4H/LObSvmusubQnd2XWzDqbK7NmZu3XwFgcEecB59XtO77m9ity86zQv7VmZnUiym0lSFoo6SZJt0r6+DDHj5G0RNJiSb+RtF3Dn4+ZWSdqYCxuBldmzayahsZpldnGUDNR96uBBcAhkhbUJRuaqHsn4BzSRN1mZlNbA2Nxs7gya2aVpYhSWwlNmajbzGwqaGAsbgqPmTWz6qr4RN1mZlNCxa9fcGXWzCoqawxWWybqNjOb/No7HrYMV2bNrJoCGKj2RN1mZpNeY2NxU7gya2aV1cAxWE2ZqNvMbCqo+pzfrsyaWXVVfKJuM7MpwZVZM7NxCKCBq481Y6JuM7NJr8GxuBlcmTWziqr+RQdmZpNf9WPx5K7MdnUxuMms8ulz3qzcN1aZiyVnpI/uvLyjN2/d7oEZ5T8m/TPz8u6fVX6q476MtACDmZ/u7nXl39NpK/Jmh+5ZmbcOd/ea8um7+jPXhM8dyJ/xWVdmWRp5bqsoCbrLxwX1ZnxxVaGp0iPzs9/Mlq6M1xuArozfkNzfssyyKOe3r9nxISf2Dea9/5H52VVXE1ckKPNzU/FYPLkrs2bW2SoeQM3MpoSKx2JXZs2smjpgnJaZ2aTXAbG4pZVZSXcAT5AatfvrJzmXtBlwJvAsYA3w7oi4rsxjzWyyifyuWytNUjewCLgnIl5Xd+zLwL7F3VnA0yJiTnHsJOC1xbF/iYgft6bEZtYe1Y/F7WiZ3TciHhrh2D8BV0fE6yXtCJwG7F/ysWY22VS8a6vDHQ3cAGxSfyAiPjR0W9IHgF2K268FdgV2BqYDl0j6VUQsb0WBzaxNKh6LKzR6HoAFwEUAEXEjMF/SVu0tkpm1RQADg+U2yyJpHql19YwSyQ8BfljcXgBcGhH9EbESWAwsbE4pzawSOiAWt7oyG8AFkq6UdMQwx68B3gAgaXdgO9Kyk2UeS/G4IyQtkrRoXf+qBhffzFoqotxmub4CfBQY9ddH0nbA9hSNDKQYvVDSLElzSUMRth3mcU/G4VjT0IKbWRtUPBa3epjBSyPiHklPAy6UdGNEXFpz/PPAVyVdDVwLXMWTk0aM9VgAIuJ04HSATWc93b9yZh3LFdVmkPQ6YFlEXClpnzGSHwycExEDABFxgaQXAX8AHgQuY5iJfTaIw91z/SaadbTqx+KWtsxGxD3F32XAz4Dd644vj4h3RcTOwDuALYHbyjzWzCaZAAYHy22WYy/gwOKi2h8B+0n63ghpD+bJIQYARMRnImLniDgAEHBzMwtrZm3WAbG4ZZVZSRtJ2njoNvBK4Lq6NHMkTSvuHk4am7W8zGPNbBKqeNdWJ4qI4yJiXkTMJ1VWL4qIQ+vTFRfhbkZqfR3a1y1pi+L2TsBOwAUtKbiZtU/FY3ErhxlsBfysWN2jB/hBRPxa0nsBIuIbwHOBsyUFcD3wntEe28Kym1k7uKLaMpJOBBZFxLnFroOBH8WGyyz1Ar8tYvFy4NCI6G9tSc2s5Soei1tWmY2I24AXDLP/GzW3LwN2KPvYsQz2drFmq/LL2Xb1lX+zunKv2sttfc9oMx/szmtgH5iel75/o/Lp12yal/e6OeWXLly7Wd6XqX+j5n35ep/IW6Jx+iN5X7Vpy8uXvXdl3vPMWbY3pS//4VV/I1/zqPxE3Z0uIi4BLiluH1937IRh0q8hzWhQnkA5S5rmpM1dWjVXzpKjg3lLVqMmfrZzlqeFvNcxd3narswO4Iz0Gsh7zaMrs+zd5fOPwcwlhHMrh4MZr2PD54Stfiz2CmBmVk0BUfGJus3MJr0OiMWuzJpZdVW8NcDMbEqoeCx2ZdbMqqvi47TMzKaEisdiV2bNrJoiPO2WmVm7dUAsdmXWzCorMi/wMDOzxqt6LHZl1swqynPImpm1X/VjsSuzZlZNQeUvOjAzm/Q6IBa7Mmtm1VXx6WDMzKaEisdiV2bNrJICiIq3BpiZTXadEItdmTWzaoqofGuAmdmk1wGx2JVZM6usqrcGmJlNBVWPxYqKX6E2EZIeBO6s2z0XeKgNxRmOyzI8l2V4k7Es20XElsMdkPTr4jxlPBQRCxtQHmuwEeIwTM7PcyO4LMNzWYbXiLKMGIehM2LxpK7MDkfSoojYrd3lAJdlJC7L8FwWm0yq9BlyWYbnsgzPZamernYXwMzMzMxsvFyZNTMzM7OONRUrs6e3uwA1XJbhuSzDc1lsMqnSZ8hlGZ7LMjyXpWKm3JhZMzMzM5s8pmLLrJmZmZlNEq7MmpmZmVnHmrSVWUkLJd0k6VZJHx/m+HRJPy6O/1HS/BaffztJv5G0WNIlkubVHDtJ0nXF9pYJluNMScskXTfC8c0k/awox58kPa/m2IckXV+U44eSZkywLNtKuljSkiLfo9tVHkkzivyvKfL89DBphn2PJO0r6eqabY2kvxtvWYo8uyVdJekXZctRHHuGpAsk3VC8rvMnUo4izzskXVs8t0XDHB/tPRr1sTa1lIg/kvS1Ik4ulrRrK89fpNmn+LxeL+n/in1jxodxlKVM/Htb8TpcK+kPkl5Qc2yOpHMk3Vh831/c5LJsKul/al6Dd9Uca+RvVJlYfJikB2ti7uHF/u0k/bnm/XvvRMpS5DlaLH55cb5+SW+sO9aMWDxaWb5c83rcLOmxmmMNe386RkRMug3oBv4CPBOYBlwDLKhL84/AN4rbBwM/bvH5/xN4Z3F7P+C7xe3XAheSVmfbCLgC2GQCZXk5sCtw3QjHTwY+VdzeEfhNcXsb4HZgZnH/J8BhE3xdtgZ2LW5vDNw8zOvSkvIAAmYXt3uBPwJ7lnmP6tJsDjwCzJrga3MM8APgF8McG7EcwCXAAcXt2RMtR5HPHcDcUY4P+x6Veay3qbWViD+vAX5VfB/3BP7Y4vPPAZYAzyjuP634O2Z8GEdZysS/lwCbFbdfXft6AGcDhxe3pwFzmlyWfwJOKm5vWcS5aTT+N6pMLD4MOHWYx04Dphe3Zxfx5+kTfJ9Gi8XzgZ2A7wBvrDvWjFg8Ylnq0n0AOLO43dD3p1O2ydoyuztwa0TcFhHrgB8BB9WlOYgUHADOAfaXpBaefwFwUXH74prjC4BLI6I/IlYCi4Fxr6YREZeSgtBI1pcjIm4E5kvaqjjWA8yU1APMAu4dbzmK/O+LiD8Xt58AbiBVUltenkhWFHd7i63+asiR3qNabwR+FRGrxluWoqX1tcAZIyQZthySFgA9EXEhQESsmEg5Moz2HpmtVyL+HAR8p/g+Xg7MkbR1C8//VuCnEXFXkX5Z8bdMfMgty5jxLyL+EBGPFncvB4Z6gzYlVcy/VaRbFxGPNbMspOe7cfG7OJv0OvbT+N+ocb/Wxeuwtrg7nQn2No8ViyPijohYDAzWPa7hsbjE70KtQ4AfFrcb+v50islamd0GuLvm/lKe+kVdnyYi+oHHgS1aeP5rgDcUt19PChpbFPsXSpolaS6wL7Btg8o1nPXlkLQ7sB0wLyLuAU4B7gLuAx6PiAsaddKiC2YX0n/hbSlP0YVzNbAMuDAiRiwLG75HtQ7mySAyXl8BPkpdgCxRjh2AxyT9tOiKOllS9wTLAumH5AJJV0o6YrTy1L5HJR9rVqtMrGymHYDNlIbvXCnpHUMHSsSHcRsl/tV6D6nVGmB74EHg28V3/QxJGzW5LKcCzyU1GlwLHB0RgzThN6rka/33xRCMcyRtW/PYbSUtJn2OToqIiTS6fIXRY/FImhGLS5VF0nakz8dQg0er6xCVMFkrs53gWGBvSVcBewP3AANFBe084A+kStJlwEATy/F5UmvI1aSuiquAAUmbkVpNtgeeDmwk6dBGnFDSbOC/gA9GxPJ2lSciBiJiZ1JFbHfVjP0sDPse1TyPrYHnA+ePtwySXgcsi4grR0k2Ujl6gJcVx19EGtZy2HjLUuOlEbErqZvz/ZJeXnd82Peo5GPNqqQHeCGpBexVwCcl7QCl4sO4jBH/htLsS6rMfqymnLsCX4+IXYCVwFOuxWhwWV4FXE2KtzsDp0rapBm/USVe6/8B5kfETqQu9LNrHnt3sf/ZwDvH20tUMhaPpKGxOLMsBwPnRMQAQBvqEJUwWSuz97DhfyLzin3Dpim6rTcFHm7V+SPi3oh4QxGYPlHse6z4+5mI2DkiDiCNJ7q5QeV6iohYHhHvKgLJO0hjo24DXgHcHhEPRkQf8FPSeK4JkdRLCp7fj4iftrs8xTkfI3XfL6zbP+J7VHgz8LOiPOO1F3CgpDtIw1H2k/S9kuVYClxdDGfpB35O+sGbkKIVfKjL9WekYTO1x0d6j8Z8rFmdMrG6mZYC50fEyoh4CLgUeEFtgpHiw3iMFf+KNDuRupYPioih36SlwNKaFstzmOB3vURZ3kUaghERcSvpmoUdoXm/UaPE4odrhhOcQfoHpP6x9wLXkSqV4zFmLB5Fo2NxTlme0jvYyjpEVUzWyuwVwHMkbS9pGunNPrcuzbnAO4vbbwQuiohGrSAx5vklzZU09PofB5xZ7O8e6sougtpOQMO69+spXSE7rbh7OGmszXJSd/6eRVeFgP1J46omci6RxnzdEBFfamd5JG0paU5xeyZwAHBjXZph36MateOUxiUijouIeRExn/Q5uSgiNmhxHqUcV5BaSLcs7u9Huphl3CRtJGnjodvAK0k/ELVphn2PyjzWrM65wDuU7EkaPnRfC8//38BLJfVImgXsAdxQJj7kKhn/nkH6R/3tEbG+AhIR9wN3S/rrYtf+TOC7XqYspJi7f5F+K+Cvgdsa/RtVMhbXjqM+kCL2S5pXPIai9+6lwE3jKUeZWDyKhsbismWRtCOwGan1dWhfS+sQlREVuAqtGRvpKtmbSbMKfKLYdyJwYHF7Bukq8VuBPwHPbPH53wjcUqQ5gyevyJxB+hIsIV0AsPMEy/FD0hjTPtJ/j+8B3gu8tzj+4qIMN5GC6GY1j/00KahcB3x3qIwTKMtLSWMqF5O6r64uXqeWl4f0Bb+qKMt1wPFl36Pi2HxSC1JXAz8z+1BctZpRjgOK53AtcBYwbYJleCZpzNU1wPU1n90x36ORHutt6m4l4o+A00hx8lpgt1aev0jzEVK8vY7U3T5ifJhgWcrEvzOAR2uOL6p5/M7AouLxP6+NjU0qy9NJlaBri9fg0GJ/o3+jysTizxUx5RpSy+2Oxf6h+HdN8feIBn1u9mH4WPyi4nO0ktSTe33NYxoai8cqS3H/BODzdekb+v50yublbM3MzMysY03WYQZmZmZmNgW4MmtmZmZmHcuVWTMzMzPrWK7MmpmZmVnHcmXWzMzMzDqWK7NmEyTpDknHtrscZmZmU5ErsxUlaStJX5X0F0lrJd0j6VeSXtPuslWJpPmSQtJuJdJ+QtLvJa2U5DnpzMzMJgFXZitI0nzgz6S1sY8jTSr9CuCXwDfaV7KON500yf9X2lwOM6sgSWdJ+kWLz7mZpAckPauV57XmkPSfkj7c7nJMNa7MVtO/F393i4ifRMRNEXFDRJxKqtgCaelDST+T9ESx/VTSvJrjJ0i6TtI7i67wlZK+LWmapH+UdLekhyV9qWa51KFu8xMkfU/SCkn313ejZ5z74KJ1+QlJP5c0ty6fd0laImmNpJslfaiuLCHpiCJArJR0m6TaZf1uL/5eUaS9ZKQXNSKOj4gvklabKUXSJZK+UbSSP1psJ9eWsTBD0n9IWi5pqaSP1OVzjKTFxXO4R9IZQ0s4Fsc3lfRdScuK1+I2SR+sO356cfwJSf9XpjXazCrvn4DzIuIvQzvcM1deEaNPHeX4yyWdW7yGIemwUdJuKenfi9/AtcU/Gb+RdEBNmrOKfOq3nYskJwKfkLRpo56jjc2V2YqRtDmwEDgtIlbUH4+Ix4p0XaR1xbcC9i22pwM/l6Sah8wHDgJeB7wBeBNpPfQXAa8EDgc+ALy+7lTHkNa/3hX4FPBZSW8Yx7nfUuT9SmAX4DM1z/UfgM8CxwPPBT4MfAz4x7qyHF+c7wXAj4EzldYwB9i9+LsQ2Lp4jo32NtJ35cXA/wOOAD5Yl+ZDpGUMdwVOAr4g6cU1xweLx/wN8Nai3P9Wc/xfgeeT3qe/Bt5NWi53aB31XwLbFMd3AS4FLtKGa5abWQeRNIsUg79Vs28+7plrpNmkZXKPBlaPkfa/SLH5PcAOpHj7K2CLunT/S/q9qd2uA4iIa4HbgEOx1mn3erreNtxIX6QAXj9GugOAAWB+zb5nkipNryjun0D68m5ak+Yc4EFq1o0GLgFOrbl/B3Bh3fnOAH6Xee41def+BHBrzf27gLfXneeDwJKa+wF8ruZ+D7CKJ9cJn1+kKb2mO/DG9NEvlfYS4GZISz8X+/4ZWFr3ev2w7nG3AP88Sr4LgbVAV3H/XODMEdLuB6wAZtbtvxr4aLs/s968TZYNOAv4RXF7OmlI0gNFLLsceGld+o2A7xTfzwdIlc9fAGeVPN8bgUfq4st5pH9kZw+Tfk7N7VHLV8SurwNfLM7xIKlCNx04DXhshBh8CanS/FXg0WI7eShWZbw2l5B6GT8LPAQsA06piXkCPgr8hfQ7de1QXM/I4yxS/K/d5o/yeq8ADhvh2Jzi8a8o+xkZJc3xFL+X3lqzuWW2ejR2EiC1ZN4bEXcM7YiI24B7gQU16e6KiMdr7j8A3BwR6+r2Pa0u/8uGuT+Ub9lz31l37nuHziNpS2Bb4D+KoQwrJK0APg/Ujx1bXHOeflJQri9vM10eRYQqXAZsI2mTmn2L6x6z/rkCSNpP0oXFEIQnSGN3pwF/VST5OvAWSddIOkXS3jV5vRCYBTxY91o9j6e+VmbWGF8g9Sy9m9Qbci3w67rekC8Ce5N6n/Yj9R69LOMcLwOuHIovZXvmMsr3NuAJYA9SbP0K8HPSP+i7AWcDZwzTwzNWb1SZcw/l0w+8BDiyyOMtxbF/JbWAvp/0u/E50u/BazPyOJoUj7/Nky2kdzM+K4rtQEkzxpnHkD8Bu0uaOcF8rCRXZqvnFtJ/h8+dQB61Fa++YY4Nt69Rn4Wxzj10nqG/7wV2rtmeR+qKr9XM8jbKiGWUtB2pi/AG0jCPF5J+BCBVaImIXwHbkVod5gK/lPTtIk0X6R+Oneu2HYFPNv6pmE1tkjYC3gd8LCJ+GRE3kGLVA6TKF5Jmk77HH4uICyPielLlbLAmn22LMZ1LijHzb6o71Xakf3yHPJvUoHHDRMtXuD4iToiIW4AvkVo3+yLiqxFxK2l8p4C96k5xH3BURNwYET8htcwek3luSL1sx0fEzUU+FwP7F3kcAxweEb+OiNsj4gfAN8vmAVA0lqwDVkXE/cU2MNprN5KioeQw0vCAxyRdVjQs7DFM8oW1DQuSflV3/F6glzT8zlqgahWCKS8iHgHOB44sguUGai4augF4ejG+aujYM0lfniUNKMqew9wfCrATPndEPED6wj8rIm6t3zLKOdTC3J3xmFx71I0F3pPUMr285ON3I1VaPxQRl0XEzQwT5CLioYj4bkQcRvpRfKek6aTxc1sBg8O8Vssm8sTMbFjPIlVGfj+0o6gk1fZQDaX5U02alRRjJwv9wAcjYgHpuoGvFBW5ITNJ3fRDyvbMlSkfbNirFaRu+mtr9vWRhhHU93SN1htV9twbnL8w1GO1AJhBas2t7W16H6P0zNXl0XAR8V+k2Py3pLGyLwEul/RPdUkvZcOGhcPrjg+NzXXLbIv0tLsANqz3kwLFIkmfJH2ZRbrQ6jjgGaQB6IuB70s6unjcv5EqPhc1oAx7SjqONMZ2H+AdpO4eGnjuTwH/Jukx0jixXtIFVNtExOdK5rGMFDheJekOYE3d0Ib1iovGNieNs6Xm6tNbh+vSq/F00o/Qv5Mu0voIqYusrFtI/zh+UNJPSZXhD9aV7UTS63c96Xv5BuC2iFgr6X9Jn4f/lvRR4EbS8ISFwP9GxG8zymJmE1N6juqIuI/UyklE3C/pIVIMWlkkeQjYrOYhtT1zP2tA+drZMzfS+btqzve3pHG7oz2mpT1zEbEGuLDYTpR0BnCCpFNqhuetGqPRZfPi74PNKqdtyC2zFVSMP92V9GU6iVRxvAg4kDR2aei/7INIX5aLi+1+4O/q/qMery+RrqK9ilRxOz4izmnkuSPiDFI33duBa4DfFs/v9tEeV5dHP3AU6T/je0mzHozkxOL5nFzcv6rYxpri6vuklt8/krrBvgV8OaOMi0lju44htVwfDtSvGLaWNNPDNaSK68akQD/0er+G9Bn4JnAT8BPSrAf3YmaN9hdSr8/67ndJ3aQxpEtq0vSRZoYZSjOLNFTqKSS9EOiOiNoxnVdR05qZ0TNXpnwTMVpvVCPOvYQU87YbprfpzsyyrqO5PXNLSA0MOeNonwfcU/RAWis0+ooyb52/ka7OP7bd5ajCRt1MD968eZu8GxvOZvAVUqvqa0gtpaeTLhDauib9N4p4uT+pUvoD4HHg23X5bk7qdXlJ3f7nk2aG2aJm3zOL895IGmP/16Tx8e8jXdBLmfINF7tIQyBOqNt3P3Bkzf1LSBeNfbU49xtJMx8cW/bco5y/9vX9V+BhUoPGs0nd9e8FjiibR3H/dOBKUo/bXGpmXSiOz+bJ4QCrSDMN7Aw8oy7dFqQGg0NJDTnbF6///dTM7lN//lE+R99q9+d5Km0eZmBmZvZUHyv+fps0bdNVwMJIQweGHEuanutcUmXuy6Tx7evHwRbj3n8OfD4i/lB7goi4VtKfgINJ02UREbdJ2pW0mMJJpPmlHyb12hyRWb7xqu2NCp7aG9WIc3+SdNHYsaTZXJaTphv8QmZZTyHNyrCENEZ1e9I/GEN2I/UeDvl0sZ1NuuBryArSFGNHkyrX00lTpP2AjGFlxUwIryfNE2wtouK/CLP1irGnp0bEKe0uS7sprSh2XUQc2e6ymFm1FRXXO4GTI+KLRVf9D4CbIuKEER6zkNQKuiDGeSV+IznmTYyk9wMHRcQr212WqcQts/YUETG/3WWoiojYp91lMLNqkrQLqZv9T6Rx7h8r/v64SLIXaU7UxZL+rtj39kirRAEQEb+WdBowj1QRts7WR1pV01rIlVkzM7PxO4Y0trSf1E3+8ohYChARv6PEhdYR8bVmFtBaJyJOb3cZpiIPMzAzMzOzjuWpuczMzMysY7kya2ZmZmYdy5VZMzMzM+tYrsyamZmZWcdyZdbMzMzMOpYrs2ZmZmbWsVyZNTMzM7OO5cqsmZmZmXUsV2bNzMzMrGO5MmtmZmZmHcuVWTMzMzPrWK7MmpmZmVnHcmXWzKYESWdKWibpuhGOS9LXJN0qabGkXVtdRjOzyaxZcdiVWTObKs4CFo5y/NXAc4rtCODrLSiTmdlUchZNiMOuzJrZlBARlwKPjJLkIOA7kVwOzJG0dWtKZ2Y2+TUrDvc0qoBV1DNro+jddPPS6QenZeQ9vT+rLHN6V+el715VOu1M5f1PEkRW+lUZyR8bmJWV9/K+GaXT9vd3Z+VNv7KSK+Mt1UBeUboG89KTkT7vWUJkPiAyPl6R+RatuX/pQxGx5XDHXrXvRvHwI+Ve6CsXr70eWFOz6/SIOD2vNGwD3F1zf2mx777MfKzGtJ5ZMXPanHYXo3KiK++LGD3l0w9My8t7sDejHLlNYNkBKiPrzDicHbcz0iszxmsw73e4mb8JTzxxz4hxGFoei8cVhyd1ZbZ3082Z/+5jSqdfPa/8J/dp2z+cVZYD512blf71m1xVOu1zp+VVIPsi7xt91bry36KfP/bCrLwvvv85pdM+8OCmWXnr4Yz/ToBpj5aP0tMez8qaaU/kBa6e1eXTKzMm5v7QrZtdPv26vLeIGz97zJ0jHXvokQH+eP68Uvn0bv2XNRGxW97ZrRVmTpvDns9+T/kH5FSWujJrVpH5ZcmhvO/VwKyMGiSwdvPppdM+MS/vv8rVf5XxHd8kr9aW+w9u17ryZel9Iu81n7Y8ryzTHi//eZm2Iu916V2Vl75rbfn0Xf15n/OLL/6nEeMwdEYsntSVWTPrZMFA5DZpT8g9wLY19+cV+8zMprCWxuJxxeFKjJmVtFDSTcXVax8f5vh0ST8ujv9R0vw2FNPMWiiAQaLU1iDnAu8orqbdE3g8IqbUEAPP+GBm9Voci8cVh9veMiupGzgNOIA0NuIKSedGxJKaZO8BHo2IZ0s6GDgJeEvrS2tmrTSYM1BsDJJ+COwDzJW0FPgU0AsQEd8AzgNeA9wKrALe1bCTd46zgFOB74xwvPZK4z1IVxrv0ZKSmVnbNCoWNysOt70yC+wO3BoRtwFI+hHparbayuxBwAnF7XOAUyUpopkDoMysnYJgoIFf8Yg4ZIzjAby/YSfsQBFx6Rg9X+uvNAYulzRH0tZTrQXbbCppZCxuVhyuwjCDka5cGzZNRPQDjwNbDJeZpCMkLZK0qH/VyiYU18xapcXDDGxsZeL1BnF4Xb/jsFmnq3osrkLLbEMVU0CcDjBz6239K2fWoQIYcEW1I9XG4U1nPd1volkH64RYXIXKbJkr14bSLJXUA2wK5M2NZWYdx62uleMZH8ymoKrH4ioMM7gCeI6k7SVNAw4mXc1W61zgncXtNwIXebys2eQWwEBEqc1aZsrP+GA21XRCLG57y2xE9Es6Ejgf6AbOjIjrJZ0ILIqIc4FvAd+VdCtpGbSD21diM2uVls4ya57xwcyGVfVY3PbKLEBEnEcKkrX7jq+5vQZ4U6vLZWbtExGsc6trS3nGBzOr1wmxuBKV2aYZhJ5V5ZN3ryg/6uLxlTOzinLv2jl56Qc2Lp326YMrsvLuzly5uS/KLws7kDlyZWCwfPoYyCt3zrrakLdud1d/Xt7dazOXs12TsZxt5hrfXf2Za8Kr/Hs02Ju7Kvgo56X6rQE2tr6Nunlwj83KP6BxH6GnaubvcWa5B6bnPSDnJ2TN0/K+OdpiTem0szZam5V3T1deWdb2la+WrFmVt2T5mhV5VZ6eFeXX4u1enbdub/favPQ5vzk5v2UAXDz64U6IxZO7MmtmHUwMNLVmY2ZmY6t+LHZl1swqKYDMRmczM2uwTojFrsyaWWVVvTXAzGwqqHosdmXWzCopTdRd7QBqZjbZdUIsdmXWzCprMKodQM3MpoKqx2JXZs2skjqhNcDMbLLrhFjsyqyZVVKg7KnezMyssTohFrsya2aVVfWuLTOzqaDqsdiVWTOrpECsi7yJxc3MrLE6IRa7MmtmlZRWnal215aZ2WTXCbF4Uldmu/tgo/vLL8I22Fv+zVqxcd5yttdtunVW+qdPf3bptN3ckpX3xl3lly4EuKNvy9Jpl60tvwwvwMo1GcsRZi7/1702r1ukJ+Nl6V2RN4P0jMfy1hfsfbyvdNqudXl5R09eUOrduLd02p41jQ0pVb/owMY2sPEgj+6bF3PKyl3iOgYzP0856TMnle+akfe93WKz8suW77rZg1l5v2CTu0un3bb3kay8ezPXVn1icEbptPeuy1gmGVi6Ni/9/avL/549unZWVt4r1+UtxdvXX/73byB3SMApJfKseCye1JVZM+tcEWIgqt0aYGY22XVCLHZl1swqa7DirQFmZlNB1WOxK7NmVklpbsNqtwaYmU12nRCLXZk1s4qqfteWmdnkV/1Y7MqsmVVSJ1xBa2Y22XVCLHZl1swqK/uqXDMza7iqx2JXZs2skjphCUUzs8muE2KxK7NmVkkB9IVDlJlZO3VCLK526cxsygpU+a4tM7PJrhNisSuzZlZZVb/owMxsKqh6LK526cxsyoqAgegqtZUhaaGkmyTdKunjwxzfTtJvJC2WdImkeQ1/UmZmHabRsbgZJnXLrPqDGQ+XX+N+3ezyayWvfbz8OskAy5bPzkp/yyZPK512857ya3YDzOlelZX+9rVblk5778pNs/Jes7r8a961Ju+L0rU2r1uka135tD1r8hZi71mZtz5576OrS6fV6rVZeUd35uu4emb5sgyUX1e9RG4NW3VGUjdwGnAAsBS4QtK5EbGkJtkpwHci4mxJ+wGfA97ekAJMYd3dwSYbl/885xjM7PocGMz77Pf3l08fmWXZaGbe93bexo+VTvv8je/JyvsFM+4qnXbbnsez8p6mwaz0jw2W/03YvDvvt2/j7jVZ6TfqLv8ePTQt7zf+8XV5sXJVf/nXpW8wr34ytsbF4maZ1JVZM+tcAY38T3934NaIuA1A0o+Ag4DayuwC4Jji9sXAzxt1cjOzTtXgWNwU1S6dmU1pA3SV2oC5khbVbEfUZbUNcHfN/aXFvlrXAG8obr8e2FjSFs14XmZmnSQjFrdFS888kTFrkk6SdF2xvaWV5Taz1gvEYJTbgIciYrea7fRxnPJYYG9JVwF7A/cAeeNDOoCkMyUtk3TdKGn2kXS1pOsl/V+xb4akP0m6ptj/6daV2szaJTMWt0XLhhlMZMyapNcCuwI7A9OBSyT9KiKWt6r8ZtZ6DfxP/x5g25r784p960XEvRQts5JmA38fEY81qgAVchZwKvCd4Q5KmgP8O7AwIu6SNDSAfy2wX0SskNQL/K6Iw5e3oMxm1kZVXzShlaVbP2YtItYBQ2PWai0ALipuX1xzfAFwaUT0R8RKYDGwsAVlNrM2CWAwukptJVwBPEfS9pKmAQcD59YmkDRX0lBmxwFnNvL5VEVEXAo8MkqStwI/jYi7ivTLir8REUNX3PQWW96VkGbWcRoci5uilWeeyJi1a4CFkmZJmgvsy4atLOtJOmJo3Fxf38qGPgEza51A9EV3qW3MvCL6gSOB84EbgJ9ExPWSTpR0YJFsH+AmSTcDWwGfac4zq7wdgM2KoV5XSnrH0AFJ3ZKuBpYBF0bEH4fLoDYO9z/uOGzWyRoZi5ularMZHAucKukw4FKKMWsRcYGkFwF/AB4ELmOEsWzFWLnTATbeZJ5bDcw62EADp4OJiPOA8+r2HV9z+xzgnIadsHP1AC8E9gdmApdJujwibo6IAWDnYijCzyQ9LyKeMva2Ng7Pes7THYfNOlwjY3EztLIyO6ExaxHxGYqWEkk/AG5ufpHNrF0i1NZuq6qRNB14OqmC+WBEPNikUy0FHi6GdK2UdCnwAmpibkQ8Juli0nCvES8kM7PO1wmxuJWlG/eYtaJra4vi9k7ATsAFLSu5mbVF1VedaTZJG0t6X1GhfBy4lVR5vF/SXZK+WfRaNdJ/Ay+V1CNpFrAHcIOkLYsWWSTNJF3Me2ODz21mFVT1WNyyltmI6Jc0NGatGzhzaMwasCgiziWNWfucpCANM3h/8fBe4LeSAJYDhxZj4Mxskgqo/KozzSTpGOATwG2kf/w/A9wLrAY2B54HvAy4UNLlwAci4pYS+f6QFGvnSloKfIoUY4mIb0TEDZJ+TbrQdhA4IyKuKxoSzi5mpukijTv+RSOfs5lVTyfE4paOmR3vmLWIWEOa0cDMpgxN6lbXEvYE9h5uTGrhT8CZkt4LvIc0N+6YldmIOKREmpOBk+v2LQZ2GeuxZjbZNDYWS1oIfJXUsHlGRHy+7vgzgLOBOUWajxf1xxFV7QKwhtJg0LOqfANu76re0mm71+S9sevW5b3UT/RNL5328YFZWXmvifLPE+DetXNKp31kdV5ZBleWf116V+f9Z9iTuRx8z6ry16lMW5E3l37PE3nrsGvFqtJpY1XeeuPqybvitEvlX/eemY0LKWk6mGq3BjRTRLy5ZLq1pHlhK6mna4CnzV4xdsJC6pgrJzI/H7mtS2v7y3+ecz+rc2fmzfKw48YPlE77vJl3j52oxoJpj5ZOu3V3XozvVt5v5YrB8vFs4668YeMz1JeVflZX+bh9X8+crLwf7c17HVcMlK8TrBtsbNWukbG45JoD/0zq+fm6pAWkRtD5o+Vb+lMmaStJx0r6ejE9FpL2krR95nMxMyul6ksoNpuknWquIzAza4sGxuIyaw4EsElxe1PS8KpRlTqzpBcCNwFvI3VnDZ3kAKbuXIxm1kSdsIRiC1wFzB26I+mXkrZuY3nMbIrJjMVzh+aYLrYj6rIrs+bACcChxZj+84APjFXGsm3RpwBfjYhPSXqiZv/5wLtK5mFmlmVwEre6llRfU385aWouM7OWyYjFD0XEbhM83SHAWRHxRUkvBr5bzGk9ONIDylZmX0hqka13H2mlHDOzhoqAvsEpX5k1M2urBsfiMdccINU3F6Zzx2WSZpB6qJaNlGnZ0q0GNhtm/46jZW5mNl6pa6va64G3QBRb/T4zs5ZocCwec80B4C7SCoRIei4wg7T664jKtsz+N/ApSW8aem6S5gMnAf9VMg8zsyxVX0KxBQR8T9LQZdUzgG9K2mC6i4g4sOUlM7Mpo1GxuOSaAx8mxbkPkf55PywiRv0nvmxl9ljSINwHgVnA70jDC35PmkLBzKyhpvrUXIWz6+5/ry2lMLMpq9GxuMSaA0uAvXLyLFWZjYjlpOUN9wN2JQ1P+HNE/G/OyczMyqv+euDNFhG+wNbM2qz6sThrZt2IuAi4CEBS3sz7ZmaZqr6EYrtI6gFmRET51QjMzMap6rG47DyzR0n6+5r73wJWS7pJ0l83rXRmNmVFwECo1DZZSdpf0pvr9n0cWAE8JunXkua0pXBmNiV0Qiwu2zJ7FPBuAEkvB94MvBX4e+CLwOuaUrpGyLjuN2MVxfzriTPf5P7B8kuOrhqclpX3msG8RvXH1pWf1nLV2ry8tbZ810V35nK23XmrvNKzpvyb2r1mxOnuhtW1pvyyygCsXVc+bX9e3tGVGXAGM55rg6+zr3rXVgt8HPjV0B1JuwOfBb4F3AB8BPhE8beSBkOs7Csfo7qyAnGe3B/bdRnL2eZa2Z8Xt3OWM105WD4twKqM12VF5C3N3Z35mj82WD6ePZH52/fEYN4UzTlLxT8xMCMr7+X9eWVZPVD+t3XNQOM/t1WPxWWf8TbA7cXtvwX+MyJ+Iula4LdNKZmZTWlDq85Mcc8nVWiHvAn4Q0T8A4Cku4F/pcKVWTPrbJ0Qi8tWtZcDTytuHwD8prjdR5oqxsys4QZRqW0Sm8OGc3nvBfy65v4VPHUpSDOzhqp6LC7bMnsBac6vPwPP5slur7/hyRZbM7OGCfKG20xS9wHPAu6WNB3YBfhkzfGNgbx+XzOzDJ0Qi8u2zL6fNKfslsAbI+KRYv+uwA+bUTAzm+IidW2V2SaxXwFfKKZFPAlYyYZDu3YCbm1HwcxsiuiAWJwzz+wHhtn/qYaXyMyMYqLuyT2EoIzjgZ8C/0uaweCdEVF7deC7gQvbUTAzmxo6IRZnX/Im6a+ADS4hjIi7GlYiM7PCJG91HVNEPAS8XNKmwIqIGKhL8iZSJdfMrGmqHotLVWaLQPo10pRcw82FUe3BFGbWcbyc7ZMi4vER9j8y3H4zs0bphFhcdszsKcALgL8D1pDmmP0IsBR4S1NKZmZTXtXHaZmZTQVVj8Vlhxm8GjgkIn4raQC4MiJ+LOk+4P8B5zSthGY2JXXC3IZmZpNdJ8Tisi2zc4A7i9uPA1sUty8DXtLgMpmZAdWf27AVJM2R9FpJL5GkumMbSTq+XWUzs6mh6rG4bGX2L8Azi9s3AAcXQfUNgMdsmVnjRfW7tppN0t+QYu5/A78DrpC0XU2S2YBnlTGz5umAWFx2mMFZpPkMLwE+D/wCOJJUGT66GQVrFEWT1vlu8nvWpcHSaQcy10yuvxx6LMv7yi/ytmZV3lrZPSvKl33aE1lZM2153ns/bUX517x7Vfn1wwG0ak1W+li1unza/syyZKUG9Zf/xDTy+9YJFx20wOdIPWBvBzYBvgr8XtK+EXFLW0tWUl9/Nw88sknp9Ooq/z0k8/OR+3kaXFf+2ubcj/7jM2Zmpe8bKF+WXuVF+b4oP7HRtr0PZ+U9Q31Z6Z8Y3Kh02vv752TlvXTd5lnp71lbPv9lazfOynv5urzFU1f395ZOm/NZKaMTYnHZeWa/XHP7Ikk7ArsBt0TEtc0qnJlNXYHoH8z7R200khaSKoPdwBkR8fm6488AziYNq+oGPh4R5zWsAOOzJ7BvRKwkLZjwZklfAi6RtC9p2JeZWdM0OhY3Q/Y8s7B+XlnPLWtmTRUNag2Q1A2cBhxAmoXlCknnRsSSmmT/DPwkIr4uaQFwHjC/IQUYv+mkhpH1IuKYYpjXJaSZZczMmqpRsbhZSldmJe0B7A88jbqxthFxVInHnwm8DlgWEc8b5vhmwJmkdcjXAO+OiOuKYx8CDicF9WuBd0VEXr+tmXWcBl5QsDtwa0TcBiDpR8BBQG1lNkhd+QCbAvc26uQTcBOpF6y2nETEhyR1kcbSZpG0LfAdYCvScz49Ir5al+ZtwMdIo1KeAN4XEdcUx+YAZwDPKx7/7oi4LLccZtY5qn6hbal2Y0nHksZtHQbsDDy/ZntKxXQEZwELRzn+T8DVEbET8A5SdyCStgGOAnYrKsHdwMElz2lmHSryLjqYK2lRzXZEXXbbAHfX3F9a7Kt1AnCopKWkVtmnLOHdBj8DDhnuQEQcDXyP/GHQ/cCHI2IBaRjD+4uW6Fq3A3tHxPOBfwFOrzn2VeDXEbEjaf7xGzLPb2YdJDMWt0XZltmjgaMi4tTxnigiLpU0f5QkC0gXlxERN0qaL2mrmnLOlNQHzKIaLSZm1mQZXVsPRcRuEzzdIcBZEfFFSS8GvivpeRGRcUVSY0XE50gXgY10/P3A+zPzvA+4r7j9hKQbSBX7JTVp/lDzkMuBebB+NciXkxo2iIh1wLqc85tZ56n6MIOyI3o3IbVUNNM1pKm+kLQ7sB0wLyLuIa1AdhcpAD8eEReMlImkI4ZaZ/r6Vja5yGbWPOVaAkq2BtwDbFtzf16xr9Z7gJ8AFN3mM4C5DXgilVU0MOwC/HGUZO8BflXc3h54EPi2pKsknSHpKZef18bhwScch806W0NjcVOUrcz+kNGHCDTC54E5kq4mde9dBQwUY2kPIgXRpwMbSTp0pEwi4vSI2C0iduvtLT/Fh5lVT4RKbSVcATxH0vaSppGGKp1bl+Yu0nUBSHouqTL7YAOfTqVImg38F/DBiFg+Qpp9SZXZjxW7eoBdga9HxC6kGRY+Xv+42jjctbHjsFmna2AsbooRhxlIOqbm7t3ApyXtBSwGNpg4LiK+NNGCFMH0XcW5RRqzdRvwKuD2iHiwOPZT0qpj35voOc2suho5t2FE9Es6EjifNO7+zIi4XtKJwKKIOBf4MPDN4oLTAA6LaNZE1XmKacPuri9PESu3LWaYycmvl1SR/X5E/HSENDuRLvR6dUQMTS66FFgaEUMtuecwTGXWzCaPTp9ntv7ihxWkSmT98rUBTLgyW1whu6oYg3U4cGlELJd0F7CnpFnAalLLyaKJns/MKi7yJ6IfNbs0Z+x5dfuOr7m9BNircWdsqNuBrYFldfs3L46VniW9qAB/C7hhpIaIovL8U+DtEXHz0P6IuF/S3ZL+OiJuIsXjJcPlYWaTRINjcTOMWJmNiO0beSJJPwT2IV11vJS0BGNvca5vAM8FzpYUwPWkri0i4o+SzgH+TLoK9yo2vLLWzCapqk8H00Kibr7ZwmzSVIY59iKtKHZtMawL0mwyz4D18fh4YAvg31Pdl/6aC+w+AHy/GK5xG0WPmplNXlWPxdmLJhTjrIiIFTmPi4hhp5epOX4ZsMMIxz6F1x83m1KC6l9B22ySvlbcDOBzklbVHO4mzZ97dU6eEfE7xpjOKyIOJ/WQDXfsatLct2Y2BXRCLM5ZNOGDwDEUczNKupc0vOArVRlXVk+DQdea8uvWd/WXfxoqny0AgwN5H4R1g+X/z8gdy9IXees256zzPNiXl/e0teXL3rMq72M2bWXejEq9T5Rfz7x75dqsvFmd13g2uGrV2IkK0Z/3YVRfXvquaeXXBM/5vo1NDAxWO4C2wPOLvyL1XtVOg7WO1GN1SqsLlUPrutBdM0unb+aPSe6CnD0Zk44p87M6MGNaVvo7V5RPv3zN9Ky879liTum02858NCvv6V15MWH1QPl480hf3sWFD6zeOCv9I6tnlU67IvM1X7um/PMEGOgr/+mNjLTlVD8Wl6oxSfoCcARwMmnxBIAXk7qitgY+2pTSmdmUVvXWgGaLiH0BJH0bOHqkWQfMzJqp6rG4bPPf4cDhEXFOzb6LJN0E/AeuzJpZg0VUP4C2SkR4XKqZtUUnxOKcMbOLR9jX6PZsMzOg+tPBtJKkt5BmD3gadXE3Ig5sS6HMbEqoeiwuWxH9DsMvmfg+4LuNK46Z2ZMiym2TnaSTSXNrzwceAx6u28zMmqbqsbhsy+x04K2SXkVapxtgD9KKXN+vueKWiDiqsUU0s6mq6l1bLfQO4JC6oV5mZi1R9VhctjK7I+mqWYDtir/3F9tza9JNgTYSM2uFoL3LI1ZMF5lTcJmZNUInxOJSldmhK2rNzFrJ/x2vdzpwKHBCm8thZlNQ1WNx9qIJZmYt0QFX0LbQHNJQrwNIF9721R708C4za5oOiMWuzJpZdVW9OaB1FvDkMIMd6475VTKz5qp4lHFl1swqa7Diq860iod6mVk7VT0WT+rKbAiiu/wbMJiRdvSVzYfLPHPJ2YwlZB/OXNIvZ6lcgOXrMpbpW5c37XDOssDKW502O33XQPkHaCDz39TuvGV+NS1jqUtlvuYZy9MCqLd8+qzv0Bg6YT1wG1v3Wtj05vLps97yJn88clZi7erPCzj9M/IKv/rx8t/Dx1ZtlpX3ohXllxu+aaOnZeXd0535ugyUj2er1+bFsnWr89LH6vK/lV2r8+Jwd8ZS7pC39HtXxjLMZXRCLPaCB2ZWTUHxH2mJbQqQ9GpJv5R0g6Rti32HS9q/3WUzs0msA2LxhCqzkrokPaNRhTEzq1X1ibpbRdLbgJ8AN5MWThhqYurGy4mbWZM1MhZLWijpJkm3Svr4CGneLGmJpOsl/WCsPEetzEqaIekbkh6UdLOko+uSbAncXq74ZmaZouQ2+X0U+IeI+BBQ2/l9ObBzW0pkZlNHg2KxpG7gNODVpAtbD5G0oC7Nc4DjgL0i4m+AD46V71gDQo4HXlf83RT4Z0kvAt4REUMDYaZGH5+ZtVj1J+puoecAlw2zfwWwSYvLYmZTSkNj8e7ArRFxG4CkHwEHAUtq0vwDcFpEPAoQEcvGynSsYQZvIbUGfD0iPg/sBuwK/EBaf9XJ1GgXMbPWc8vskHuBHYbZ/3LgLy0ui5lNNeVj8VxJi2q2I+py2ga4u+b+0mJfrR2AHST9XtLlkhaOVbyxWma3Bm5Y/1wi7pS0L3AR8CPgmLFOYGY2Lh0wUXcLnQ58TdLhxf1tJb0M+AJeFczMmikvFj8UEbtN8Iw9pN6ofYB5wKWSnh8Rj432gNHcBzwbuGNoR0Q8UFw9ezHwnYmV18xsFFOj1XVMEfEFSZsCFwIzSPF3LXBKRJzW1sKZ2eTXuFh8D7Btzf15xb5aS4E/RkQfcLukm0mV2ytGynSsYQYXA2+t3xkR9wP7FYUwM2sSldwmv4j4BDCXNOZsT2DLiPhke0tlZlNDw2LxFcBzJG0vaRpwMHBuXZqfk1plkTSXNOzgttEyHatl9l946tKJAETEfZL2Bl45VsnNzMYlc+GLyUzSW4D9gadRNERI6ccjIg5sX8nMbNJrUCyOiH5JRwLnk6YWPDMirpd0IrAoIs4tjr1S0hJgAPhIRDw8Wr6jVmYj4k7gzlGO3wecnfdUzMxKGJqo25B0Mml6motJF4N5AIaZtUaDY3FEnAecV7fv+JrbQbomq/R1WZN6OVsz62xTYUGEkt4BHBIR57S7IGY29VQ9Fk/qyqwCNFD+HVDGm6XMJvcYyPuvZkXftNJpH1wzOyvvNQN561MvXzWjdNrc9al71pRP252RFqB7dd6b1L2q/ELsWr02K+9Yk1f4GBhoSloAZax9DkBG/jnft1IqHkBbqAu4ut2FGI/utcGmt+d9X8oKNbflXoMZvx/9efFmYEZ3VvreleXjdk9mHF7zxMzSaZdvVP73ACB68r7Eyvit7Fqb9/5PW5OXvmd1+bTdGWkBetbkvS7da8un717XhMBZ8Vg8oeVszcyaquLrgbfQ6cCh7S6EmU1RFY/FLWuZlbQtaSqvrUh1/NMj4qt1aTYDzgSeBawB3h0R1xXHPgQcXjz2WuBdEZHZVmdmnSSnt2SSmwO8VdIBwGKgr/ZgRBxVNqOSsXhT4HvAM0i/E6dExLeLYycBry2S/ktE/Hg8T8jMOkfVY3GplllJF0maM8z+TSRdVPJc/cCHI2IBaVqZ99evxwv8E3B1ROxEGiP21eI82wBHAbtFxPNIV8AdXPK8ZtaJyq44UzLISloo6SZJt0r6+DDHvyzp6mK7WdJjDXkejbGANMxgHWmGmefXbM/LzKtMLH4/sCQiXkCaIueLkqZJei1pFcidgT2AYyV5OV2zyazBsbgZyrbM7gMMN4hzBvCyMhkUMx/cV9x+QtINpCXMatfjXQB8vkhzo6T5kraqKetMSX3ALNIVvWY2aTWu20pSN3AacABpQu4rJJ0bEevjT0R8qCb9B4BdGnLyBoiIfRuYV5lYHMDGSnN/zQYeIVWCFwCXRkQ/0C9pMbAQ+EmjymdmVVP94VyjtsxK2lXSrsXdnYbuF9uLgCN46soNY5I0n/RD8ce6Q9cAbyjS7A5sB8yLiHuAU4C7SEH48Yi4IPe8ZtZhGtcasDtwa0TcFhHrSMtxHzRK+kOAH4673B1ilFh8KvBcUqPBtcDRETFIitELJc0qJjPflw1X8zGzyajDW2YX8WQRh6s8rgY+kHNCSbOB/wI+GBHL6w5/HviqpKtJAfQqYKAYS3sQsD3wGPCfkg6NiO8Nk/8RpEo2M3o3zSmamVVN+eA4V9KimvunR8TpNfe3Ae6uub+U1E3+FJK2I8WaskOoWqLopXo/qXU0SC2p/x4RD4wzv9Fi8atIwxr2I13DcKGk30bEBUVDxh+AB4HLSJOa1+e9Pg5Pnz5nPMUzsyqp+JjZsSqz25PWJ7uN1LLxYM2xdcCyiCg9b4+kXlLw/H5E/LT+eBFQ31WkFXB7ce5XAbdHxIPFsZ8CLyFdoFCfx+mkK3/ZdNbTK/7ym9mIAhgs3bX1UETs1qAzHwyckxPbmk3SXsCvgQdIFUiAtwEfkvSqiLhsxAcPn9+osZgUhz9fTF5+q6TbSWN1/xQRnwE+U+TzA+Dm+gfXxuFNNpnnOGzWyfJicVuUWQEMGjCFV1E5/RZwQ0R8aYQ0c4BVRTfg4aSxWcsl3QXsKWkWqTV4f1KrsZlNYg28gvYeNuwOn8fIQ6QOJrWAVskppGEP7y26+5HUBXwD+CLpn/tSysRi0pCu/YHfFi3Cfw3cVow9nhMRD0vaCdiJ4XvtzGwSqfpsBqWn5pI0D3g5NeuCDxklINbaC3g7cG0xjADS7AXPKPL4BmmM1tmSArgeeE9x7I+SzgH+TLoI4SqK//rNbBJrXAC9AniOpO1JldiDgbfWJ5K0I7AZT7Z+VsXOwGFDFVmAiBiU9CVSPMxRJhb/C3CWpGtJvXMfi4iHJM0gVXABlgOHFheDmdlkNhkqs5LeRpr/tZ801KD2aQUwZmU2In5HCoqjpbkM2GGEY58CPlWmvGZmtSKiX9KRwPmkqf3OjIjrJZ0ILIqIc4ukBwM/KrrXq+Rx0rCvm+r2D11HUFrJWHwv8Mph9q8hjdk1M6uMsi2zJ5K6sj5ZpXFkY4kuMTCz/BKA/dPLjwkZmJH3W9c1Le9l6+3KXC83w9qBvLUy1q0t/xp2Zy4v2J2xymVPxnJ+AN3rctccLp9/dGWOH+rJe827pk8vX5Zp5Zc+BtC0vOWMmVG+LDnftzIa2bUVEecB59XtO77u/gmNO2ND/Qj4lqSPki6+gtTCehIVn3VBfQNMu/+JJmXe5HF8Of/TDOTFm96evOVse1bPKp92TfnvLMC05eVHEvbNzht1OJi5NJMyfipzlngF6FmdmT5jydmeNZnLp+f+nq3NWFa8r/H1h8kyzGAr4IxOqsia2SRQ8bkNW+ijpNbUM3kybvcBXweesgCEmVlDVTwWl63Mnkeaxua2JpbFzOxJbZ63sEqKi2KPlnQcaaosgL9ExKo2FsvMpoIOiMVlK7MXAidJ+hvS/K/164IPN7WLmdnEVDyAtlpErCqmycIVWTNrmYrH4rKV2f8o/v7TMMeCdEGFmVlDVX2cVitJ+iBwDGkBCCTdS7r49isVvGDNzCaRqsfiUpXZiJjwPLNmZtkqHkBbRdIXSCtqncyT04a9GDge2Jo0ptbMrDkqHoszrzM0M2sNBah5k3p0msOBwyPinJp9F0m6idRz5sqsmTVFJ8TiUi2uSv5R0vWSVkl6ZrH/45Le3NwimtmUFSq3TQ2LR9jnnjMza66Kx+KyQfBo4J9Jq27VlvYe4MhGF8rMDHjyKtqxtsnvOwy/xO77gO+2uCxmNtVUPBaXHWbwXuAfIuKXkv61Zv+fgb9pfLHMzKp/0UELTQfeKulVwOXFvj2ApwPfl/S1oYQRcVQbymdmk1jVY3HZyux2wHXD7O8DZjauOGZmNSoeQFtoR1LjAaR4DHB/sT23Jp1fMTNrvIpHlrKV2duAXYE76/a/BljS0BKZmQFE9VsDWiUi9m13GcxsiuqAWFy2MnsKcKqkWaQxsy+W9HbSFbTvblbhJqxLDM4oPwXuwIzyWQ9OyyuKMi/R6B8s/4CVfXnrcK9cl1f4gb7yZentz8qarr7y35Cu/rxvkwYy0/dlrH3dn7eycwxmRoKu8gPp1Z03KYlmZHzQgZhZ/vOV830rd/LGZmdtMDCAHnuiOXl3Nfnat8GMS7hzp/rtyfve9gyUL8usjLQAPavLf8f7Nsp7zQd78i4KyonzPWvynmd3dvrycb5rbd6PX87vTXb6vswf4jIqHovLzjP7bUk9wGeBWaQLDu4FjoqIHzexfGY2lVU8gLaSpK2AvYCnUXfxbkT8e1sKZWZTQ8Vjcel/DSPim8A3Jc0FuiJiWfOKZWZW/a6tVpF0KHAGqWfsUTb8aQnAlVkza5qqx+LsRRMi4qFmFMTMzEb0GeALwIkR0YQ+RDOzzlWqMitpc1Iw3Z/hu7g2aXzRzGxK64BVZ1poE+AsV2TNrOU6IBaXbZn9FrALadGEe6n86AkzmxQcaYZ8H3gt8G/tLoiZTUEVj8VlK7P7AwdExB+bWRgzsw1UPIC20DHAzyXtD1xLmuN7vYg4sS2lMrOpoeKxuGxldhmwopkFMTOrJap/0UEL/T9gIfAQ8GyeegGYK7Nm1hSdEIvLVmY/AZwo6Z0R4UqtmbVGxQNoC30S+HBEfLndBTGzKajisbhsZfafgfnAMkl38tQurp0aXC4zm+o6YNWZFuoGzm13IcxsCuqAWFy2MntOU0thZjacigfQFvo28DY8nMDM2qHisbjsCmCfbnZBzMyeouIBtIVmAYdLehWwmKf2jh3VllKZ2dRQ8VictWiCpP2ABaSndX1EXNKMQjVKAIPd5deFjiYu8527bHcOZbb/93TlTRjX1VM+/8hchiPnNY+8Jb6rJfJe88hYW11q7vr00VU+/5zvWxlV79pqoecCVxW3d6w7Vu1XaTCI1aubk3eTP/tZMr/jdHdnJVfGj0h35g/O9P7yZe9Z2ZuVd2TGBGWUpXvtQF7e6/KmadaavrETDaXty5wCeiCv7PSXTx/9jZ+OuuqxuOyiCdsAPwNeSJpnFuDpkhYBr4+Ie0d8sJnZeFU8gLZKROzb7jKY2RRW8Vhc9t/arwEDwLMjYtuI2BZ4TrHva2UykDRD0p8kXSPpeklPGbogaTtJv5G0WNIlkuYV+/eVdHXNtkbS35Usu5l1omLVmTLbVCBpK0knSjpH0n9KOkHS08aRT5lYfJikB2ti7uHF/u0k/bnYd72k9zbiuZlZhXVALC7bKXwAsE9E3D60IyJuk3QU8JuSeawF9ouIFZJ6gd9J+lVEXF6T5hTgOxFxdjGk4XPA2yPiYmBnWL+07q3ABSXPa2adquKtAa0iaS/g18ADwGXF7kOBYyS9KiIuG/HBT1UmFgP8OCKOrNt3H/DiiFgraTZwnaRz3TtnNslVPBbnDDga7qmUfnqRDM1R21ts9Y9fAFxU3L4YOGiYrN4I/CoiVpU9t5l1JkW5bQo4BfghsENEvD0i3g7sAPwI+GJORiVj8UiPXRcRa4u708n7DTGzDtXIWCxpoaSbJN0q6eOjpPt7SSFpt7HyLBuIfgP8m6Rta07yDOArlG+ZRVK3pKtJK4pdOMzyuNcAbyhuvx7YWNIWdWkOJgV1M5vsouRWQpkAKunNkpYUXeg/aMAzaJSdgS9GPHmVUXH7S8AuuZmViMUAf18M+TqnLvZvK2kxcDdwkltlzaaABsViSd3AacCrSQ2Yh0haMEy6jYGjgeFi01OUrcweBWwE3CbpzmLhhL8U+0pPCRMRAxGxMzAP2F3S8+qSHAvsLekqYG/gHtK4XAAkbQ08Hzh/pHNIOkLSIkmL+vpWli2amVVN2eDZoAAq6TnAccBeEfE3wAcb80Qa4nFg+2H2bw88lptZiVj8P8D8YkGcC4Gzax57d7H/2cA7JW1Vn39tHF4XTZrJwMxao4GxGNgduDUibouIdaTepeF64f8FOAlYUybTUpXZiLgb2BV4Dam76xTg1RGxa0QsLZNHXX6PkYYRLKzbf29EvCEidiEtoTuUdsibgZ9FxIjzZUTE6RGxW0Ts1tu7UW7RzKwilLGVUCaA/gNwWkQ8ChARyyb8JBrnR8C3JL1N0vbFdihwBhPoqRolFj9cM5zgDNJMNvWPvRe4DnjZMMfWx+Fpmjne4plZBWTG4rlD/8gW2xF12W1D6tUZsrTY9+T5pF2BbSPil2XLWHpW0IgI0n/oF5Z9TC1JWwJ9EfGYpJmki8pOqkszF3ik6D47DjizLptDiv1mNhWUHw87t5gqcMjpEXF6zf3hAugedXnsACDp96TlY0+IiF9nlbd5Pkr6rTiTJ+N2H/B1YMQxZ8MpGYu3joj7irsHAjcU++cBD0fEakmbAS8Fvjy+p2RmHaN8LH4oIsYc4zoSpYnTvwQclvO40pXZYiqsY0hddJCC25ci4mcls9gaOLvo7usCfhIRv5B0IrAoIs4F9gE+p7QKwKXA+2vOPx/YFvi/smU2s86WcXHXhAJooYc05eA+pO73SyU9v653qC2K1uSjJR0HPKvY/ZdxXghbJhYfJelAoB94hCd/WJ4LfLGI0QJOiYhrx/3EzKwjNPBC23tIdbkh84p9QzYGngdcIgngr4BzJR0YEbUNFhsou2jCh4HPAt8Bzip2vxj4gaRPRsQpY+UREYsZ5kKFiDi+5vY5wDkjPP4O6pqizWySa10AhdRa+8diGNPtkm4mVW6vaFgpJqiovE6o8lgyFh/HML1gEXEhsNNEzm9mHahxsfgK4DmStifF4IOBt64/TcTjwNyh+5IuAY4drSIL5VtmjwWOjIhv1uw7U9KfgBNJY2grR0BXf/l3oGtdRt7lV7kDYHBd3tKFq/vKrwvb2523LF7uZzJnudzBvKfJwLTySx3mpAUYmJ43a1BPb0bhM5Z4HZfB8rNPZy9dmJk+Z5nGnO9bKS0KoIWfk4YyfbsY8rQDcFvDSjAOkl5NGkqwU0Qsrzu2KWkGmH8oKpnVFEGsywiYGZ/97O+hmrgmdu6a5d2ZM8xnlF2Zr0tXd/n0OcvNAkTma66MZV7Vl7mc7drMH+6cJWr78vLOWbIcyIvbuUvlltGgWBwR/ZKOJF3I3w2cGRHX1/UMZStbY5pNukig3sXFMTOzxorGrShTMoCeD7xS0hLSLCofiYiHG1OCcTsSOLm+IgupBUPSSaRZF6pbmTWzztbAWAwQEecB59XtO36EtPuUybNsZfbnpMUKPl+3/++BcdWizczG0sgFEcYKoMVFrscUW1XsxOjluYhi5hczs2ap+uI0ZSuztwIfl7QvTy6luGexfUnS+mAbEV9qbBHNbMqqeABtgS2B0dpEAqhfWMbMrLEqHovLVmYPAx4ljSHboWb/o8C7au4HaUoFM7MJq3prQAssJbXO3jLC8Z146oVsZmYNVfVYXKoyGxHDrTxjZtY8GUvVTmK/BP5F0nkRGy6lJWkW6QLc0hOLm5ll64BYXP6SeTOzVqt4AG2Bz5CuV7hZ0qnAjcX+55IuDhNp2kQzs+apeCzOWTTh9cC+wNOoWwY3It7c4HKZ2RQnqt+11WwRsUzSS0jTc32WJ1fvDdLsC++PiAfaVT4zm/w6IRaXXTThi8AHgN8DD5CmrTEza66KB9BWiIg7gdcUy8c+m/TbcktEPNrekpnZlFHxWFy2ZfadwJsi4r+bWRgzs1rKnYh+EpG0fUTcPnS/qLwOuxqZ0rqP8yLi7laVz8ymjqrH4rLLfqziybFaZmbNFxnb5HSZpG9JevFICSRtJul9wBLgoNYVzcymjA6IxWVbZj8PfFTS/4uIzLUzzczGp+rjtJpsR9KCCL+UNAhcCdwLrAE2AxaQLgT7E/DBiDi/XQU1s8mt6rG4bGX2m8DfAvdIuhnYYBHiiNiv0QVrhOiCvtnlJ2zon1V+DenBaXnvbPf0vGHGM3vL/8+w8bS1WXmv7c+bxOLxGeXXnF41c3pW3v2zukun7Zudt8Z3d1/5vAG6+vPKnpV3T2ZZVme8p115r0vMyHueA5vOLJ025/tWRiOXUOw0EfEY8BFJxwOvBV4KbAfMBB4CzgbOj4jr2lbIEiKCyFnjPi/z5uTbAnnfWmAg48vQn/d6a235GJ8rjYDJ0F/+t1K5n6vM9NGX8bpkvuYM5NUJIuf9z8y7jKrH4rK/PN8gBdJfky4A69wIYmadw5GGYn7Zc4rNzKz1Kh6Ly1Zm3wK8PiIubGZhzMzWi+p3bZmZTXodEIvLXgD2IF4y0cxareIXHbSDpJmSthlm/9+0ozxmNgVUPBaXrcx+CjhR0uxmFsbMbMjQRN1ltqlC0huBW0gXhS2WtEfN4e+2qVhmNol1QiwuO8zgI8B84AFJd/HUC8B2anC5zMw6+gKfJvln4IUR8YCkFwJnS/psRPyAcVxTZGZWSsVjcdnKrC88MLOWm0qtriX1Di1fGxFXSno58DNJz2bKDbgws1apeiwuVZmNiE83uyBmZhuYguNhS1gmaaeIWAwQEY9IOoA0TZd7yMys8TogFmdNCilpP9JE3QFcHxGXNKNQZmZQ/bkN2+DtwAYTWkbEOuAQSae2p0hmNtlVPRaXqswWV87+DHghaQUagKdLWkSasuveER9sZjZeFW8NaLWIWDrKsd+3sixmNoVUPBaXbZn9GjAAPDsibgeQ9Ezge8WxNzaneGY2ZQVosOIRtEUknTnCoSAtb3sr8GM3LJhZw3VALC5bmT0A2GeoIgsQEbdJOgr4TVNKZmZTXtUvOmihLYGXAYPA0PK1zyPNYHAl8AbS9Ikvi4ir21JCM5u0qh6Lc8bMDvdUKv30QhAZzzDKzrqbmRagqytvwMn0nvLrPM/qWZdXlsy3bVpGWVZOy3ueAzO6S6ftn5E381Bu+u6Z5cvSta43K2/1Zw446s78gGWIaVlD5RmcVv51yfm+lcuwwfl1rt8DK4D3RMQqAEmzgG8C1wCvAb4DfBHYv12FHFYE0YS14gEUmbORqXnfq2y5gxAzXsMYzMtbOe9Pf+ZrqLz3SP05Zcn8XPWX/y0Dsl7zrLRADDTx/W/G963isbjsp/I3wL9J2nZoh6RnAF/BLbNm1gSdMFF3Cx0NnDhUkQUobn8G+FBxEdhJwM7tKZ6ZTVadEIvLVmaPAjYCbpN0p6Q7gb8U+47KOaGkbklXSfrFMMe2k/SbYmWbSyTNqzn2DEkXSLpB0hJJ83POa2YdJqL8NvnNBrYeZv9fFccAlpPR2zZGLH65pD9L6i9WHas95lhsNpV0QCwuO8/s3ZJ2BV4B7FjsviEi/ncc5zwauAHYZJhjpwDfiYizi2nAPkeaigZSF9pnIuLCYlndik8UYWYTNUVaXcv4GfAtSR8Frij2vQj4AvDT4v7uwM0ZeY4Wi+8CDgOOHeaYY7HZFFP1WFz6v/iICODCYhuXoqX1taSusWOGSbKgZv/FwM+Lxy0AeiLiwqIsK8ZbBjPrIBUPoC30XuBLpBlkhuJ2P3AmT1Y4bwD+oUxmY8XiiLijSDdY9zjHYrOpqOKxeNRhBpJeLekOSU/5z13SpsWxAzLO9xXgo4z8n/w1pKtyAV4PbCxpC2AH4DFJPy26xU6WVP6qFDPrSFUfp9UqEbEqIt4LbA7sUmybR8T7ImJlkebqjJkMvsLosXgkjsVmU1DVY/FYY2aPBE6OiOX1ByLicdIFBx8scyJJrwOWRcSVoyQ7Fthb0lXA3sA9pPlte0jT0hxL6lp7JqkLbLjzHCFpkaRF/WtXlimamVVRAINRbpsiImJlRCwutnEFuJKxeCSlYnFtHO5j7XiKaWZV0QGxeKzK7E7AaONiLwJeUPJcewEHSroD+BGwn6Tv1SaIiHsj4g0RsQvwiWLfY8BS4OqIuC0i+knDD3Yd7iQRcXpE7BYRu/VM36hk0cyskqLkVoKkhZJuknSrpI8Pc/wwSQ9KurrYDm/Qs2gISVtJOlHSOZL+U9KnJW01jqzGjMWjKBWLa+NwL9PHUUQzq5QGxuJmGKsyuyWjd0MFsEWZE0XEcRExLyLmAwcDF0XEobVpJM2V1k8EeBxpPBikCx7mSNqyuL8fsKTMec2sc2kwSm1j5pO6wk8DXk0am39IMf6z3o8jYudiO6Oxz2b8JO1FWuXrrcBq0qpfbwNukfTinLzKxOJROBabTUGNisXNMlZldimpdXYkO5GGAoxb0dJwYHF3H+AmSTcDW5EuTiAiBkjdWr+RdC1p2rNvTuS8ZlZ9DRyntTtwa9GiuI7UInlQM8veYKcAPwR2iIi3R8TbSeNXf0RaKGHCamOxpBdJWgq8CfgPSdeDY7HZVFX1MbNjzWbwS+BfJJ0XEatrDxSrz5xYpMkSEZcAlxS3j6/Zfw5wzgiPuZDRK9ZmNpnkdVvNlbSo5v7pEXF6zf1tgLtr7i8F9hgmn7+X9HLSFFcfioi7h0nTDjsDh0XE+p6yiBiU9CXgqvFmOkosvgKYN8JjHIvNppI2DyEoY6zK7GeANwI3SzoVuLHY/1zSxWECPtu84k1MdIl1G5Vfeq9/Vvm8BzbKWy5u09mrx05UY5uNHiuddt6M8mkBVg1Oy0rfn7F274pVeePj+laUvxC6e23eMopdfZnLKA6Uz1+Z67ZGd15ZspbLzQwyg9PzLj7v36h8+pzv21jSqjOln9xDEbHbBE/5P8API2KtpP8HnE3qRq+Cx4HtgZvq9m8PPNby0uSK5kxFG4N5nzdlLiveTJG7FG/GhPTZ3b0Z6ZW5DGt0ZT7PnKV4M5ftzV9Ctnz6Zi5PC2S+Lo2teWbG4rYY9Rc5IpZJegnwdVKldehTGcD5wPsj4oHmFtHMpqzG1T3uAbatuT+PuiFSEfFwzd0zSAsSVMWPeHLRhD8U+/YizSjzw7aVysymhur8HzisMZuXIuJO4DWSNgOeTarQ3hIRjza7cGY2tTWwNeAK4DmStidVYg8mXUz15LmkrSPivuLugaRFCKrio6TYeyYpbgtYR2poeMrMDGZmjdTRLbO1isrrFWMmNDNrhAaO04qIfklHknqUuoEzI+J6SScCiyLiXOCo4gKofuARRpjLuh2Ki9aOlnQc8Kxi918iYlUbi2VmU8EkGDNrZtYmkTVOcMzcIs4DzqvbV3vR03GkKQErQdK5JdIAEBEHjpHUzGycGhuLm8GVWTOrrKmwVO0oHh47iZlZ81U9Frsya2bVVfHWgGaKiHe1uwxmZkDlY3Hj5tExM2ukAA1Eqc3MzJqkwbG4xNLix0haImmxpN9I2m6sPF2ZNbPqqvh64GZmU0KDYnHJpcWvAnaLiJ1IC2mNOU2iK7NmVlmKKLWZmVnzNDAWj7m0eERcXDNTy+WMsBphLY+ZNbPqckXVzKz9ysfiRi0tPuQ9wK/GOqkrs2ZWTUHlV50xM5v08mJxI5YWB0DSocBuwN5jpZ3UldnohnUbl18Xum92xvrUs/uzyrLNJsuz0v/N7PvGTlTYfvqyrLxXDU7PSp/joVUbZaV/4InyZelbl7fGtwYy1wTPEF3dWel7p+WN6OleUz7/3ClTBqbnvS59s8qXPef7NhbhIQSTRtPex7z/dmKwOiPrlBdC8kTmf4E570/me6ncf0hz8h/MfZ5NTt9E0cZY2OBYPObS4gCSXgF8Atg7ItaOlemkrsyaWYdzZdbMrP1au7T4LsB/AAsjolRrnSuzZlZdrsyambVfg2JxyaXFTwZmA/9ZrHJ411irHLoya2bV5DGzZmbt1+BYXGJp8Vfk5unKrJlVlsfMmpm1X9VjsSuzZlZRkX+Bh5mZNVj1Y7Ers2ZWTYHHzJqZtVsHxGJXZs2suqrdGGBmNjVUPBa7MmtmlVX1cVpmZlNB1WOxK7NmVl0VD6BmZlNCxWOxK7NmVk0BDFY7gJqZTXodEItdmTWziorKtwaYmU1+1Y/Fk7oyG93Qt0n5teL7Ny4/wnnjTVZnleU5s0utyLbeHrP+Ujrts3uXZ+W9NvMzOUN9pdM+sm5WVt5PrJ5eOu2qgY2y8mYwb/FzRfnPSrbMrKM7Yw35zPezf0ZeYfo2Kp8+5/tWSsUDqNm45bZ0NXNqpJzvWbO/kzmvS25ZctPnlCX3/Wnq+9mEvCseiyd1ZdbMOlzFA6iZ2ZRQ8Vjc0sqspDuAJ4ABoD8idqs7vhlwJvAsYA3w7oi4rsxjzWyS6YBxWp1MUjewCLgnIl5Xd+zLwL7F3VnA0yJiTnHsJOC1xbF/iYgft6bEZtYWHRCL29Eyu29EPDTCsX8Cro6I10vaETgN2L/kY81sUgkYHGh3ISazo4EbgE3qD0TEh4ZuS/oAsEtx+7XArsDOwHTgEkm/ioi8sU5m1kGqH4szBua1xALgIoCIuBGYL2mr9hbJzNpiqDWgzGZZJM0jta6eUSL5IcAPi9sLgEsjoj8iVgKLgYXNKaWZVUIHxOJWV2YDuEDSlZKOGOb4NcAbACTtDmwHzCv5WDObbCLKbZbrK8BHGWNdH0nbAdtTNDKQYvRCSbMkzSUNRdi2ieU0syqoeCxu9TCDl0bEPZKeBlwo6caIuLTm+OeBr0q6GrgWuIo0RrbMYwEoKrpHAPRuslkzn4uZNZsrqg0n6XXAsoi4UtI+YyQ/GDgnIgYAIuICSS8C/gA8CFzGkzG69hzr4/AM8mY4MbMKqngsbmnLbETcU/xdBvwM2L3u+PKIeFdE7Ay8A9gSuK3MY2vyOD0idouI3bpnZU7lZGYVUrIloOJBtoL2Ag4sLqr9EbCfpO+NkPZgnhxiAEBEfCYido6IA0iTzt1c/6DaONxL+en3zKyKqh+LW1aZlbSRpI2HbgOvBK6rSzNH0rTi7uGksVnLyzzWzCaZIM3FWGaz0iLiuIiYFxHzSZXViyLi0Pp0xUW4m5FaX4f2dUvaori9E7ATcEFLCm5m7dEBsbiVLbNbAb+TdA3wJ+CXEfFrSe+V9N4izXOB6yTdBLyadLXtiI9tYdnNrB0a2BogaaGkmyTdKunjo6T7e0khaUpN/yfpREkH1uw6GPhRxAYvcC/wW0lLgNOBQyOiv5XlNLM2qHjLbMvGzEbEbcALhtn/jZrblwE7lH2smU1yDQqOxZyqpwEHAEuBKySdGxFL6tJtTPon+o8NOXHFRcQlwCXF7ePrjp0wTPo1pBkNzGwqqfhwrkm/AljOiqbRW/7Nmjmt/BKvAFv0rsxKv1X3itJp5/XMzsq7L/Lmi3t4WvmleOfNeCwr71tmbVk67epZeWPvBlbndTz0rym/FGvX2rxlWwfWZSVHGW+Rcld07M4r+2BP+fSZKwiPoaFTvewO3Fr8Y4ykHwEHAUvq0v0LcBLwkUad2Joo+wc2sxtUVZu9sqTsZVszXpdmV2oy8o+KV7Aaqq1TEFZ/CsQO/aaa2aQXEDFYagPmSlpUs9VP37cNcHfN/aXFvvUk7QpsGxG/bOrzMjPrJHmxuC0mfcusmXWwgdLB8aGJLHEtqQv4EnDYePMwM5u0ysfitnBl1syqKaKRV8few4aT+88r9g3ZGHgeaXlWgL8CzpV0YEQsalQhzMw6TmNjcVO4Mmtm1dW4MXFXAM+RtD2pEnsw8NYnTxOPA3OH7ku6BDjWFVkzM3wBmJnZeEWDWgMiol/SkcD5QDdwZkRcL+lEYFFEnNuQE5mZTUKNisXN4sqsmVVUY+ctjIjzgPPq9h0/Qtp9GnZiM7OOVv2VFl2ZNbNqCio/HYyZ2aTXAbHYlVkzq642TvViZmaFisdiV2bNrJICiIq3BpiZTXadEItdmTWzaoqofGuAmdmk1wGx2JVZM6usqrcGmJlNBVWPxZrMaxtLehC4s273XOChNhRnOC7L8FyW4U3GsmwXEVsOd0DSr6mZ+3UMD0XEwgaUxxpshDgMk/Pz3Aguy/BcluE1oiwjxmHojFg8qSuzw5G0aCLLXjaSyzI8l2V4LotNJlX6DLksw3NZhueyVE9XuwtgZmZmZjZersyamZmZWceaipXZ09tdgBouy/BcluG5LDaZVOkz5LIMz2UZnstSMVNuzKyZmZmZTR5TsWXWzMzMzCYJV2bNzMzMrGNN2sqspIWSbpJ0q6SPD3N8uqQfF8f/KGl+i8+/naTfSFos6RJJ82qOnSTpumJ7ywTLcaakZZKuG+H4ZpJ+VpTjT5KeV3PsQ5KuL8rxQ0kzJliWbSVdLGlJke/R7SqPpBlF/tcUeX56mDTDvkeS9pV0dc22RtLfjbcsRZ7dkq6S9Iuy5SiOPUPSBZJuKF7X+RMpR5HnHZKuLZ7bomGOj/YejfpYm1pKxB9J+loRJxdL2rWV5y/S7FN8Xq+X9H/FvjHjwzjKUib+va14Ha6V9AdJL6g5NkfSOZJuLL7vL25yWTaV9D81r8G7ao418jeqTCw+TNKDNTH38GL/dpL+XPP+vXciZSnyHC0Wv7w4X7+kN9Yda0YsHq0sX655PW6W9FjNsYa9Px0jIibdBnQDfwGeCUwDrgEW1KX5R+Abxe2DgR+3+Pz/CbyzuL0f8N3i9muBC0mrs20EXAFsMoGyvBzYFbhuhOMnA58qbu8I/Ka4vQ1wOzCzuP8T4LAJvi5bA7sWtzcGbh7mdWlJeQABs4vbvcAfgT3LvEd1aTYHHgFmTfC1OQb4AfCLYY6NWA7gEuCA4vbsiZajyOcOYO4ox4d9j8o81tvU2krEn9cAvyq+j3sCf2zx+ecAS4BnFPefVvwdMz6Moyxl4t9LgM2K26+ufT2As4HDi9vTgDlNLss/AScVt7cs4tw0Gv8bVSYWHwacOsxjpwHTi9uzi/jz9Am+T6PF4vnATsB3gDfWHWtGLB6xLHXpPgCcWdxu6PvTKdtkbZndHbg1Im6LiHXAj4CD6tIcRAoOAOcA+0tSC8+/ALiouH1xzfEFwKUR0R8RK4HFwLhX04iIS0lBaCTryxERNwLzJW1VHOsBZkrqAWYB9463HEX+90XEn4vbTwA3kCqpLS9PJCuKu73FVn815EjvUa03Ar+KiFXjLUvR0vpa4IwRkgxbDkkLgJ6IuBAgIlZMpBwZRnuPzNYrEX8OAr5TfB8vB+ZI2rqF538r8NOIuKtIv6z4WyY+5JZlzPgXEX+IiEeLu5cDQ71Bm5Iq5t8q0q2LiMeaWRbS8924+F2cTXod+2n8b9S4X+vidVhb3J3OBHubx4rFEXFHRCwGBuse1/BYXOJ3odYhwA+L2w19fzrFZK3MbgPcXXN/KU/9oq5PExH9wOPAFi08/zXAG4rbrycFjS2K/QslzZI0F9gX2LZB5RrO+nJI2h3YDpgXEfcApwB3AfcBj0fEBY06adEFswvpv/C2lKfowrkaWAZcGBEjloUN36NaB/NkEBmvrwAfpS5AlijHDsBjkn5adEWdLKl7gmWB9ENygaQrJR0xWnlq36OSjzWrVSZWNtMOwGZKw3eulPSOoQMl4sO4jRL/ar2H1GoNsD3wIPDt4rt+hqSNmlyWU4HnkhoNrgWOjohBmvAbVfK1/vtiCMY5krateey2khaTPkcnRcREGl2+wuixeCTNiMWlyiJpO9LnY6jBo9V1iEqYrJXZTnAssLekq4C9gXuAgaKCdh7wB1Il6TJgoInl+DypNeRqUlfFVcCApM1IrSbbA08HNpJ0aCNOKGk28F/AByNiebvKExEDEbEzqSK2u2rGfhaGfY9qnsfWwPOB88dbBkmvA5ZFxJWjJBupHD3Ay4rjLyINazlsvGWp8dKI2JXUzfl+SS+vOz7se1TysWZV0gO8kNQC9irgk5J2gFLxYVzGiH9DafYlVWY/VlPOXYGvR8QuwErgKddiNLgsrwKuJsXbnYFTJW3SjN+oEq/1/wDzI2InUhf62TWPvbvY/2zgnePtJSoZi0fS0FicWZaDgXMiYgCgDXWISpisldl72PA/kXnFvmHTFN3WmwIPt+r8EXFvRLyhCEyfKPY9Vvz9TETsHBEHkMYT3dygcj1FRCyPiHcVgeQdpLFRtwGvAG6PiAcjog/4KWk814RI6iUFz+9HxE/bXZ7inI+Ruu8X1u0f8T0qvBn4WVGe8doLOFDSHaThKPtJ+l7JciwFri6Gs/QDPyf94E1I0Qo+1OX6M9KwmdrjI71HYz7WrE6ZWN1MS4HzI2JlRDwEXAq8oDbBSPFhPMaKf0WanUhdywdFxNBv0lJgaU2L5TlM8LteoizvIg3BiIi4lXTNwo7QvN+oUWLxwzXDCc4g/QNS/9h7getIlcrxGDMWj6LRsTinLE/pHWxlHaIqJmtl9grgOZK2lzSN9GafW5fmXOCdxe03AhdFRKNWkBjz/JLmShp6/Y8Dziz2dw91ZRdBbSegYd379ZSukJ1W3D2cNNZmOak7f8+iq0LA/qRxVRM5l0hjvm6IiC+1szyStpQ0p7g9EzgAuLEuzbDvUY3acUrjEhHHRcS8iJhP+pxcFBEbtDiPUo4rSC2kWxb39yNdzDJukjaStPHQbeCVpB+I2jTDvkdlHmtW51zgHUr2JA0fuq+F5/9v4KWSeiTNAvYAbigTH3KVjH/PIP2j/vaIWF8BiYj7gbsl/XWxa38m8F0vUxZSzN2/SL8V8NfAbY3+jSoZi2vHUR9IEfslzSseQ9F791LgpvGUo0wsHkVDY3HZskjaEdiM1Po6tK+ldYjKiApchdaMjXSV7M2kWQU+Uew7ETiwuD2DdJX4rcCfgGe2+PxvBG4p0pzBk1dkziB9CZaQLgDYeYLl+CFpjGkf6b/H9wDvBd5bHH9xUYabSEF0s5rHfpoUVK4DvjtUxgmU5aWkMZWLSd1XVxevU8vLQ/qCX1WU5Trg+LLvUXFsPqkFqauBn5l9KK5azSjHAcVzuBY4C5g2wTI8kzTm6hrg+prP7pjv0UiP9TZ1txLxR8BppDh5LbBbK89fpPkIKd5eR+puHzE+TLAsZeLfGcCjNccX1Tx+Z2BR8fif18bGJpXl6aRK0LXFa3Bosb/Rv1FlYvHniphyDanldsdi/1D8u6b4e0SDPjf7MHwsflHxOVpJ6sm9vuYxDY3FY5WluH8C8Pm69A19fzpl83K2ZmZmZtaxJuswAzMzMzObAlyZNTMzM7OO5cqsmZmZmXUsV2bNzMzMrGO5MmtmZmZmHcuVWbMJknSHpGPbXQ4zM7OpyJXZipK0laSvSvqLpLWS7pH0K0mvaXfZqkTSfEkhabcSaT8h6feSVkrynHRmZmaTgCuzFSRpPvBn0trYx5EmlX4F8EvgG+0rWcebTprk/yttLoeZVZCksyT9osXn3EzSA5Ke1crzWnNI+k9JH253OaYaV2ar6d+Lv7tFxE8i4qaIuCEiTiVVbIG09KGkn0l6oth+KmlezfETJF0n6Z1FV/hKSd+WNE3SP0q6W9LDkr5Us1zqULf5CZK+J2mFpPvru9Ezzn1w0br8hKSfS5pbl8+7JC2RtEbSzZI+VFeWkHREESBWSrpNUu2yfrcXf68o0l4y0osaEcdHxBdJq82UIukSSd8oWskfLbaTa8tYmCHpPyQtl7RU0kfq8jlG0uLiOdwj6YyhJRyL45tK+q6kZcVrcZukD9YdP704/oSk/yvTGm1mlfdPwHkR8ZehHe6ZK6+I0aeOcvzlks4tXsOQdNgoabeU9O/Fb+Da4p+M30g6oCbNWUU+9dvORZITgU9I2rRRz9HG5spsxUjaHFgInBYRK+qPR8RjRbou0rriWwH7FtvTgZ9LUs1D5gMHAa8D3gC8ibQe+ouAVwKHAx8AXl93qmNI61/vCnwK+KykN4zj3G8p8n4lsAvwmZrn+g/AZ4HjgecCHwY+BvxjXVmOL873AuDHwJlKa5gD7F78XQhsXTzHRnsb6bvyYuD/AUcAH6xL8yHSMoa7AicBX5D04prjg8Vj/gZ4a1Huf6s5/q/A80nv018D7yYtlzu0jvovgW2K47sAlwIXacM1y82sg0iaRYrB36rZNx/3zDXSbNIyuUcDq8dI+1+k2PweYAdSvP0VsEVduv8l/d7UbtcBRMS1wG3AoVjrtHs9XW8bbqQvUgCvHyPdAcAAML9m3zNJlaZXFPdPIH15N61Jcw7wIDXrRgOXAKfW3L8DuLDufGcAv8s895q6c38CuLXm/l3A2+vO80FgSc39AD5Xc78HWMWT64TPL9KUXtMdeGP66JdKewlwM6Sln4t9/wwsrXu9flj3uFuAfx4l34XAWqCruH8ucOYIafcDVgAz6/ZfDXy03Z9Zb94mywacBfyiuD2dNCTpgSKWXQ68tC79RsB3iu/nA6TK5y+As0qe743AI3Xx5TzSP7Kzh0k/p+b2qOUrYtfXgS8W53iQVKGbDpwGPDZCDL6EVGn+KvBosZ08FKsyXptLSL2MnwUeApYBp9TEPAEfBf5C+p26diiuZ+RxFin+127zR3m9VwCHjXBsTvH4V5T9jIyS5niK30tvrdncMls9GjsJkFoy742IO4Z2RMRtwL3Agpp0d0XE4zX3HwBujoh1dfueVpf/ZcPcH8q37LnvrDv3vUPnkbQlsC3wH8VQhhWSVgCfB+rHji2uOU8/KSjXl7eZLo8iQhUuA7aRtEnNvsV1j1n/XAEk7SfpwmIIwhOksbvTgL8qknwdeIukaySdImnvmrxeCMwCHqx7rZ7HU18rM2uML5B6lt5N6g25Fvh1XW/IF4G9Sb1P+5F6j16WcY6XAVcOxZeyPXMZ5Xsb8ASwBym2fgX4Oekf9N2As4EzhunhGas3qsy5h/LpB14CHFnk8Zbi2L+SWkDfT/rd+Bzp9+C1GXkcTYrH3+bJFtK7GZ8VxXagpBnjzGPIn4DdJc2cYD5Wkiuz1XML6b/D504gj9qKV98wx4bb16jPwljnHjrP0N/3AjvXbM8jdcXXamZ5G2XEMkrajtRFeANpmMcLST8CkCq0RMSvgO1IrQ5zgV9K+naRpov0D8fOdduOwCcb/1TMpjZJGwHvAz4WEb+MiBtIseoBUuULSbNJ3+OPRcSFEXE9qXI2WJPPtsWYziXFmPk31Z1qO9I/vkOeTWrQuGGi5StcHxEnRMQtwJdIrZt9EfHViLiVNL5TwF51p7gPOCoiboyIn5BaZo/JPDekXrbjI+LmIp+Lgf2LPI4BDo+IX0fE7RHxA+CbZfMAKBpL1gGrIuL+YhsY7bUbSdFQchhpeMBjki4rGhb2GCb5wtqGBUm/qjt+L9BLGn5nLVC1CsGUFxGPAOcDRxbBcgM1Fw3dADy9GF81dOyZpC/PkgYUZc9h7g8F2AmfOyIeIH3hnxURt9ZvGeUcamHuznhMrj3qxgLvSWqZXl7y8buRKq0fiojLIuJmhglyEfFQRHw3Ig4j/Si+U9J00vi5rYDBYV6rZRN5YmY2rGeRKiO/H9pRVJJqe6iG0vypJs1KirGThX7ggxGxgHTdwFeKityQmaRu+iFle+bKlA827NUKUjf9/tVcPAABAABJREFUtTX7+kjDCOp7ukbrjSp77g3OXxjqsVoAzCC15tb2Nr2PUXrm6vJouIj4L1Js/lvSWNmXAJdL+qe6pJeyYcPC4XXHh8bmumW2RXraXQAb1vtJgWKRpE+SvswiXWh1HPAM0gD0xcD3JR1dPO7fSBWfixpQhj0lHUcaY7sP8A5Sdw8NPPengH+T9BhpnFgv6QKqbSLicyXzWEYKHK+SdAewpm5ow3rFRWObk8bZUnP16a3DdenVeDrpR+jfSRdpfYTURVbWLaR/HD8o6aekyvAH68p2Iun1u570vXwDcFtErJX0v6TPw39L+ihwI2l4wkLgfyPitxllMbOJKT1HdUTcR2rlJCLul/QQKQatLJI8BGxW85DanrmfNaB87eyZG+n8XTXn+1vSuN3RHtPSnrmIWANcWGwnSjoDOEHSKTXD81aN0eiyefH3wWaV0zbkltkKKsaf7kr6Mp1EqjheBBxIGrs09F/2QaQvy8XFdj/wd3X/UY/Xl0hX0V5FqrgdHxHnNPLcEXEGqZvu7cA1wG+L53f7aI+ry6MfOIr0n/G9pFkPRnJi8XxOLu5fVWxjTXH1fVLL7x9J3WDfAr6cUcbFpLFdx5Barg8H6lcMW0ua6eEaUsV1Y1KgH3q9X0P6DHwTuAn4CWnWg3sxs0b7C6nXZ333u6Ru0hjSJTVp+kgzwwylmUUaKvUUkl4IdEdE7ZjOq6hpzczomStTvokYrTeqEedeQop52w3T23RnZlnX0dyeuSWkBoaccbTPA+4peiCtFRp9RZm3zt9IV+cf2+5yVGGjbqYHb968Td6NDWcz+AqpVfU1pJbS00kXCG1dk/4bRbzcn1Qp/QHwOPDtunw3J/W6vKRu//NJM8NsUbPvmcV5bySNsf9r0vj495Eu6KVM+YaLXaQhECfU7bsfOLLm/iWki8a+Wpz7jaSZD44te+5Rzl/7+v4r8DCpQePZpO769wJHlM2juH86cCWpx20uNbMuFMdn8+RwgFWkmQZ2Bp5Rl24LUoPBoaSGnO2L1/9+amb3qT//KJ+jb7X78zyVNg8zMDMze6qPFX+/TZq26SpgYaShA0OOJU3PdS6pMvdl0vj29eNgi3HvPwc+HxF/qD1BRFwr6U/AwaTpsoiI2yTtSlpM4STS/NIPk3ptjsgs33jV9kYFT+2NasS5P0m6aOxY0mwuy0nTDX4hs6ynkGZlWEIao7o96R+MIbuReg+HfLrYziZd8DVkBWmKsaNJlevppCnSfkDGsLJiJoTXk+YJthZR8V+E2XrF2NNTI+KUdpel3ZRWFLsuIo5sd1nMrNqKiuudwMkR8cWiq/4HwE0RccIIj1lIagVdEOO8Er+RHPMmRtL7gYMi4pXtLstU4pZZe4qImN/uMlRFROzT7jKYWTVJ2oXUzf4n0jj3jxV/f1wk2Ys0J+piSX9X7Ht7pFWiAIiIX0s6DZhHqghbZ+sjrappLeTKrJmZ2fgdQxpb2k/qJn95RCwFiIjfUeJC64j4WjMLaK0TEae3uwxTkYcZmJmZmVnH8tRcZmZmZtaxXJk1MzMzs47lyqyZmZmZdSxXZs3MzMysY7kya2ZmZmYdy5VZMzMzM+tYrsyamZmZWcdyZdbMzMzMOpYrs2ZmZmbWsVyZNTMzM7OO5cqsmZmZmXUsV2bNzMzMrGO5MmtmU4KkMyUtk3TdCMcl6WuSbpW0WNKurS6jmdlk1qw47MqsmU0VZwELRzn+auA5xXYE8PUWlMnMbCo5iybEYVdmzWxKiIhLgUdGSXIQ8J1ILgfmSNq6NaUzM5v8mhWHexpVwCqatunMmPFXm5RO36VoWln6B/P+b+jr7y6dVuvy8u7qy0qOBjLSDublTc5LrsysM/9VGyz/khO9mWXpyftsqbt8+q6uvBddma9jzvdCWW8oPHHzsociYsvhjr1q343i4UfKffiuXLz2emBNza7TI+L0rMLANsDdNfeXFvvuy8zHakzrmRUzezct/4DI+AwNZAacwdwAVR2R87rkpG22zHijroxA3J0Z5Lsz8gaiu3zhoyvviebkDRA5yTNf81UPLx0xDkPLY/G44vCkrszO+KtN2PM/Dimdflp3Rq0t0yOrZ2Wlv++h8sG/e+mMrLxn3Zv3SZ/+aPnA2Ls6s2KV8ZJHXhyib1ZeoFuzefnXZfVf5f1Y9G2Z9x/E9I3Xlk47a8a6vLx7+7PSz+gpn356d17eF+771TtHOvbQIwP88fx5pfLp3fovayJit6yTW0vM7N2UFz/r3aXTa035z3M8sTKrLLFmzdiJag007zch97/K6C//3Yp1eTGhmZVf9eRVM7pmb1Q+7403zsp7cNPZWen755T/be3bOK+Foz/z92lgevnPy0Bv3mfryrM+PGIchs6IxZUYZiBpoaSbigG/Hx/m+HRJPy6O/1HS/DYU08xaKhiIwVJbg9wDbFtzf16xb8rwRXJm9lQtjcXjisNtr8xK6gZOIw36XQAcImlBXbL3AI9GxLOBLwMntbaUZtZqAQwSpbYGORd4R1Fh2xN4PCKm2hCDs/BFcmZWo8WxeFxxuArDDHYHbo2I2wAk/Yg0AHhJTZqDgBOK2+cAp0pSZA0iMrNOM0jjxjhK+iGwDzBX0lLgU0AvQER8AzgPeA1wK7AKeFfDTt4hIuLSMXq+1l+cAVwuaY6kradgpd9sSmlULG5WHK5CZXa4wb57jJQmIvolPQ5sATzUkhKaWcsFwUAD/1+NiFEH0BcVtPc37ISTky+SM5tiGhmLmxWHq1CZbShJR5C6v5ixVd7gcDOrlgYOIbAW2iAO95afUcbMqqnqsbjtY2YpN9h3fRpJPcCmwMPDZRYRp0fEbhGxW++mM5tQXDNrhQAGiFKbtUypizNq4/C07ryZXMysWjohFlehMnsF8BxJ20uaBhxMGgBc61zgncXtNwIXebys2eQWQF8MltqsZXyRnNkU0wmxuO3DDIoxsEcC5wPdwJkRcb2kE4FFEXEu8C3gu5JuJa0ccXD7SmxmreJqamv5IjkzG07VY3HbK7MAEXEeKUjW7ju+5vYa4E2tLpeZtU94CEHL+SI5M6vXCbG4EpVZM7OnCBiodvw0M5v8OiAWT+rK7NpV07jl6m3HTjgkYwW4nGVYAbpX5y0vt9Gj5dPPfDDvUzbzkbylVXtXlF9GUetyl7PNSJ+59vXg9Lz1b2c+VP7rMPOhvLzXbD4tK33f7PLpV87Me/9X5K26yGDGU43uBk6lRfW7tmxs0SUGZ5b/0Kmr/KUcuRd9qLuJl4lkLk9LxvMEiHUZcbsvbznb6MtbhjqHevOqGZpRfgnZmJEXV6M3c030jPdUg3mxr3td82qHXX2NzbsTYvGkrsyaWScTAzn/YZqZWRNUPxa7MmtmlRRAZmOHmZk1WCfEYldmzayyqt4aYGY2FVQ9Frsya2aVlCbqrnYANTOb7DohFrsya2aVNRjVDqBmZlNB1WOxK7NmVkmd0BpgZjbZdUIsdmXWzCopEH2ROZWOmZk1VCfEYldmzaySOqE1wMxssuuEWOzKrJlVlBiIJk5yb2ZmJVQ/Frsya2aVlFadqXYANTOb7DohFk/qymzPaph7dXOaxpW5UHHP2rzF4HpXlE/fuzxv6cLuFWuz0mtN+WUUlbssYjRxJubM5SJ7M5ZGnP5I+SUXAWZtkrmc7UblxycNTMtc5jfzWx85ywhnLul5xxjHq961ZWNTgNaWX/9bAxlrhefGm+l538OsmeJzY1kTY1/kLBMOkPOaZ8p+lt0Zvzdr8n77unoyx31m/IRoMG+d8MFpeb9P3d3lY2H0NL7iWfVYPKkrs2bWuSKq37VlZjbZdUIsdmXWzCprsOKtAWZmU0HVY7Ers2ZWSekK2mq3BpiZTXadEItdmTWziqp+15aZ2eRX/VjsyqyZVVInXEFrZjbZdUIsdmXWzCopEOsqvuqMmdlk1wmx2JVZM6uswYp3bZmZTQVVj8WuzJpZJXXCRQdmZpNdJ8RiV2bNrJICMRDVng7GzGyy64RY7MqsmVVW1S86MDObCqoei12ZNbNKiqDy08GYmU12nRCLJ3VltnvtIJv+ZXX5B2Ssw63Mta/Vl5e+a23G+tSr12blzbryeQNERvroz1wrPTLXEM+hzC9fT/mvQ88T07Oy7n50Rlb66TPLryE/OC3vKtPsdbvVru4lVX7VGSspZ115Mj7P03uziqH+gaz0Mb18TMj9TWAw8zdkIKPsGbEMIDLLkkPdmVfBd2Wk78nNOzP2ZaTP7YWPzLgaOd+hhtc7qx+LJ3Vl1sw6V1D91gAzs8muE2JxS0snaaGkmyTdKunjwxzfTtJvJC2WdImkeTXHTpJ0XbG9pZXlNrP2GKCr1GblSTpT0jJJ142SZh9JV0u6XtL/FftmSPqTpGuK/Z9uXanNrJ2qHotbdmZJ3cBpwKuBBcAhkhbUJTsF+E5E7AScCHyueOxrgV2BnYE9gGMlbdKioptZGwRiMMptluUsYOFIByXNAf4dODAi/gZ4U3FoLbBfRLyAFIsXStqzqSU1s7brhFjcymEGuwO3RsRtAJJ+BBwELKlJswA4prh9MfDzmv2XRkQ/0C9pMSkY/6QF5TazNgigLzwSqtEi4lJJ80dJ8lbgpxFxV5F+WfE3gBVFmt5iK3+hgZl1pE6Ixa1sE94GuLvm/tJiX61rgDcUt18PbCxpi2L/QkmzJM0F9gW2bXJ5zaytxEDJzRpqB2CzYqjXlZLeMXRAUrekq4FlwIUR8cd2FdLMWqX6sbhqVe1jgVMlHQZcCtwDDETEBZJeBPwBeBC4DBj20k5JRwBHAMyYvmkrymxmTRBUfwnFSaoHeCGwPzATuEzS5RFxc0QMADsXQxF+Jul5EfGUsbcbxOFex2GzTtYJsbiVpbuHDVtT5xX71ouIeyPiDRGxC/CJYt9jxd/PRMTOEXEAIODm4U4SEadHxG4RsVtv70ZNeBpm1ipVbw2YpJYC50fEyoh4iNSw8ILaBEVcvpgRxt7WxuFpPbOaXV4za7Kqx+JWVmavAJ4jaXtJ04CDgXNrE0iaK62fHPQ44Mxif3cx3ABJOwE7ARe0rORm1nIRYjC6Sm1TgaTpRfxcIGnLJp7qv4GXSuqRNIt00e0NkrYsWmSRNBM4ALixieUwswrohFjcsmEGEdEv6UjgfKAbODMirpd0IrAoIs4F9gE+JylIrQHvLx7eC/xWaZLh5cChxcVgZjaJVX1uw2aTtDFwKHAI6SLaXlLPVEi6hxRPT4+IKzLy/CEp1s6VtBT4VJEvEfGNiLhB0q+BxcAgcEZEXFc0JJxdzEzTBfwkIn7RoKdqZhVW9Vjc0jGzEXEecF7dvuNrbp8DnDPM49aQZjQwsykioPKrzjSTpGNIw61uI/VifQa4F1gNbA48D3gZcKGky4EPRMQtY+UbEYeUSHMycHLdvsXALplPw8w6XCfE4qpdAGZmVlBDWwMkLQS+SuoZOiMiPl93/BnA2cCcIs3Hi3/A22VPYO/hLrAq/Ak4U9J7gfcAewNjVmbNzPI0NhY3w6SuzKpvgJ4HHi+ffjBjysTctawz1wSnv/woiujry8u7L2+ERmSUJfd1SVNXls07c0rLrrz/JJWzVvbatXllWZOXvmv6tPJpezPXYe/ODEo5r0vO+zlWVtCwSbhrFm05gHSB0xWSzo2I2nmu/5nUdf71YkGX84D5DSnAOETEm0umW0ta5GBS0EBmrMyR+fnUQEY8y/metCJ9s2S+hlkxHlBkvOa5v8PZv9vl06snL6525Xy2AFQ+/8ycx9TIWAzNaVgo/epI2krSsZK+Xsz1iqS9JG2f9zTMzMpp4BKK6xdtiYh1wNCiLbUCGFpZcFNSl35bSdqp5qJYM7O2aFQsLrka7FDDwi6kyQLG/Ge9VJCU9ELgJuBtpO6soYB/AGkcl5lZQwWiP7pLbaSLmRbVbEfUZVdm0ZYTgEOLi6LOAz7QpKeW4ypg7tAdSb+UtHUby2NmU0xmLB5LUxoWyvZPngJ8NSI+JemJmv3nA+8qmYeZWWkRMFC+a+uhiNhtgqc8BDgrIr4o6cXAd4tFARrda5ej/gV4OWkhAzOzlsiMxXMlLaq5f3pEnF5zf7iGhT3q8jgBuEDSB4CNgFeMddKyldkXklpk690HbFUyDzOzLA0cpzXmoi2kGLcQICIukzSD1Cq6rFGFMDPrRBmxuC0NC2XHYq0GNhtm/4440JtZEwQNnah7zEVbgLtIS7gi6bnADNLy2e0UxVa/z8ysJRoci8s2LPwEUsMCKRbPZRRlW2b/G/iUpDcV90PSfOAk4L9K5mFmlqVRyyOWXLTlw8A3JX2IVGE8LHIvxW48Ad+TNDQdxgxSGVfVJoqIA1teMjObMhq4VO36hgVSJfZg4K11aYYaFs4q27BQtjJ7LOmCiAeBWcDvSMMLfk+66uz/s3fn8XJUZf7HP9+7ZScBEhBJICggREVAZBGVTTToDIyKCoiKioz+QEBEBkZFxVFBEDcYnQgIuICYAYdRFJBlcAElCAQSBGLYQpA9CVnv9vz+OHWTTufe2+fcVHdXdz/v16tet7vq9KnT29PnVp06j3PO5Srv6WAikrbMB/bNbYf5uKzs/k/q0grnXMvKMxZX68BCVGfWzJYRcnUfCOxOGJ7wVzP73cifknPODUd1zfVdBGbmF9g65+os31hcjQMLSbOtm9nNwM0AkjpTHuucc6mKnkKxXiR1AKPNbHm92+Kca35Fj8Wx88yeKOk9JfcvBlZJelDSq6rWOudcyxqYDiZmaVaSDpL0vrJ1pwPLgSWSfitpUl0a55xrCY0Qi2OPzJ4IfBRA0luA9xEG7L4H+CbwT1Vp3cbq70crVkUXt5RUd6kpFxNT1yWlkE1MZ2upafQSptm01JSzdZ3Cc32WkGgpKc0lI0jR2Z9Qvictna3aGufUfasPMwBOB34zcEfSnsDXgIuBB4DPAp/L/haTGeqOj2dakxDPElNzp6QJByDlu5KabjY1LWxKnE+Nq0lpxascs1PeozXdSVWrPWpS/7XaqphC2PrSYps649ve1pF/u4sei2N/BbcGHslu/zPwCzO7StJ9wO+r0jLnXEsLWWeKHUBr4LWEDu2A9wJ/MrOPA0h6AvgPityZdc41tEaIxbGtWwZskd0+GLgpu91DmDLBOedyNXAFbczSxCax/lze+wK/Lbl/Jxum5XXOudw0QiyOPTJ7A2GahL8C27PutNerWXfE1jnnclX0U1s18BTwSuAJSaOA3YAvlGyfAKwZ7IHOOZeXosfi2NYdT5hTdgpwuJm9kK3fHbiiGg1zzrW4yCMBTX5k9jfAN7JpEc8BVrD+0K5dgAX1aJhzrkU0QCxOmWf2U4Os/2LuLXLOObJTWwWfDqYGzgSuBn5HmMHgw2ZWetXLR4Eb69Ew51xraIRYnHYZNCDpZUBX6Tozezy3FjnnXKbJj7pWZGbPAW+RNBFYbmbl01y8l9DJdc65qil6LI7qzGaB9LuEKbm6BimSNt+Fc85VkHc620ZmZkuHWP/CYOudcy4vjRCLY8fMnge8DvgXYDVhjtnPAouA91elZc65llf0cVrOOdcKih6LY4cZHAIcaWa/l9QH3GVmP5f0FPCvwOyqtdA515IM76g651y9NUIsjj0yOwl4LLu9FNg8u3078Mac2+Scc0C46CBmaWaSJkl6p6Q3SuunJJI0TtKZ9Wqbc641FD0Wx3Zm/w68Irv9AHBEFlTfDfiYLedc7sygt78tamlWkl5NiLn/A/wBuFPStiVFxgM+q4xzrmoaIRbHDjO4lDCf4a3A2cCvgBMIneGTqtGwXBhYb0KO+/6Esn0JZQFLzSGeUL8l5hu3/rSc4El5vhPzjRdLyvOsbh72pM9XYv7w5Pe/LaH+1LorVtfcR10jfJ1wBuyDwCbAd4A/SjrAzB6ua8timUFKHE757CfGvqp+DxNZaltSyqd+D1NiSFtx/nlMfQ2V+n4mfG5V5ddFKW9/FTqVRY/FsfPMfqvk9s2SdgL2AB42s/uq1TjnXOtqhHFaNbA3cICZrSAkTHifpPOBWyUdQBj25ZxzVdMIsXhE3Xcze9zMrk7pyEq6RNIzku4fYvumkq6RNFfSXyS9pmTbpyXNk3S/pCskjR5Ju51zjcVMUUsTG0WYGWctMzsFuIpwpmzn1AolTZN0i6T5WVzd4OyapA9ksfg+SX+S9LqSbZMkzZb0N0kPSNon+Vk55xpK0WNxdNIESXsBBwFbUNYJNrMTI6q4FLgAuHyI7f8O3GNm78qO/F4IHCRpa+BEYIaZrZJ0FXBEVp9zrok1+8VdER4knAWbX7rSzD4tqY0wljZVL/AZM/urpAnAXZJuNLPSfTwC7GdmL0o6BJgF7JVt+w7wWzM7XFIXMHYEbXDONZCix+LYpAmnAt8g5ABfzPpHCqJGcpjZbZKmD1NkBmE8Lmb2N0nTJW1Z0s4xknoIgXNxzD6dc43LrPjjtGrgGuBIBjkIYGYnSeoAPplSoZk9BTyV3X5J0gPA1pR0mM3sTyUPuQOYCmsT6LwFOCYr1w2Uptd1zjWZRojFscMMTgJONLMdzWx/MzugZDkwp7bcS5gdAUl7AtsCU83sSULShscJAXipmd2Q0z6dcwVW9FNb1WZmXzezQ4bZfryZjfhqj+wAw27An4cp9jHgN9nt7YBngR9JulvSRZLGjXT/zrnGUPRYHBsENwGuq2ZDCEdlJ0m6B/gUcDfQJ2lT4DBCEH05ME7S0UNVIuk4SXMkzenuX1XlJjvnqicu40zRjxgUlaTxwH8DJ5vZsiHKHEDozP5btqoD2B34vpntRrgo7fRBHrcuDvd5HHausRU/Fsd2Zq8AZlazIWa2zMw+Yma7Ah8CpgALgbcCj5jZs2bWA1zNMIkazGyWme1hZnt0tY2pZpOdc1VW9KMBjUpSJ6Ej+1Mzu3qIMrsAFwGHmdnz2epFwCIzGziSO5vQuV3PenG43eOwc42u6LF4yDGzkk4pufsE8GVJ+wJzgZ7SsmZ2/sY2RNIkYGU2ButY4DYzWybpcWBvSWOBVYSL0OZs7P6cc8VmFH+cVq1I2gZ4wsom1syS10wzs8cT6hJwMfDAULE729/VwAfN7KGB9Wb2D0lPSHqVmT1IiMfzB6vDOdccGiEWD3cB2KfK7i8nHBEtPypqQMXOrKQrgP2ByZIWEbLWdAKY2Q8IU8xcJsmAeYRTW5jZnyXNBv5KuAr3bsKVtc65ZmbQV/AAWkOPAFsBz5St3yzb1p5Q176EJAz3ZcO6IMwmsw2sjcdnEtKW/2eWQbfXzPbIyn4K+Gk2k8FC4COpT8Y510AaIBYP2Zk1s+3y3JGZHVlh++3AjkNs+yKestG5lmLgQwjWEYPPHDMeWJ1SkZn9IatvuDLHEs6QDbbtHsJ0Yc65FtAIsTh6ntkB2UUDmNny/JvjnHMD/OIuSd/NbhrwdUkrSza3A3sC99S6Xc65VlL8WJySNOFk4BTCfIRIWkwYXvDt8nFchZKSV75Ab1ZVX1LrTyxfkLc3JX/4SKpvTzhTm1J2JOWVMNtSSllA7dXLIT7ySaKGqK8gH706em32V4ShWKVzunYThl+dV+tGJTFQT298+b7E+JTSlNQPVH9C+WrH1YTX0HoTXm+A/vi2p76GSo3bKa95SllI/2wlvC7q60urO1VCW9p684/xRY/FsUkTvgEcB5wL3J6t3ocwrmor4LSqtM4519KKfmqr2szsAABJPwJOGmoKLeecq6aix+LYI7PHAsea2eySdTdLehD4L7wz65zLmVnxA2itmJlfZOWcq4tGiMUpY2bnDrGueucsnXMtrejjtGpJ0vsJU2FtQVncNbND69Io51xLKHosju2IXg4cP8j6TwI/zq85zjm3TjgiUHlpdpLOBX4CTAeWAM+XLc45VzVFj8WxR2ZHAUdJejtwR7ZuL0J62Z+WXHGLmZ2YbxOdc62q6Ke2auhDwJFlQ72cc64mih6LYzuzOxGumgXYNvv7j2zZuaRcCxwjcc7VguGpaku04VNwOefqoBFicVRnduCKWuecqxkr/jitGpoFHA18qc7tcM61mgaIxclJE5xzrmb8XM+ASYShXgcTLrztKd3ow7ucc1VV8FjsnVnnXGEV/dRWDc1g3TCDncq2FfxnxjnX6Ioei70z65wrrFaYqSCGD/VyztVT0WNxc3dm29rQ2DHx5Xvj09FZd3flQiWS/6dJ+OSkfsZS22KpKQMTKCXdcGLa1qRUxoA64r8O6kz86owaldaWzs74woltsSqms1WOqUiN4h8NcDGqOGdPtVOrtseXt97Ez35i+tOkNLIJqU9hBOlvUyTE1apLff9Tylc53XoK5fx9a4RY7AkPnHPFZIApbmkBkg6R9GtJD0ialq07VtJB9W6bc66JNUAs3qjOrKQ2Sdvk1RjnnCuV50TdkmZKelDSAkmnD1HmfZLmS5on6Wd5PpeNIekDwFXAQ4TECQOH7tvxdOLOuSoretKEYTuzkkZL+oGkZyU9JOmksiJTgEeq1zznXEuzyKUCSe3AhcAhhIupjpQ0o6zMDsAZwL5m9mrg5JyeRR5OAz5uZp8GSs8J3wHsWpcWOedaR06xuFoqDWY5E/in7O9E4POS3gB8yMwGBuW0xjk+51yN5TpR957AAjNbCCDpSuAwYH5JmY8DF5rZiwBm9kxeO8/BDsDtg6xfDmxS47Y451pK8ZMmVBpm8H7C0YDvm9nZwB7A7sDPpLVX4xT8GjfnXMPK72jA1sATJfcXZetK7QjsKOmPku6QNHOj2p6vxYT2lXsL8Pcat8U512pyPDJbjSFflY7MbgU8MHDHzB6TdABwM3AlcEpc051zLpElXUE7WdKckvuzzGxW4h47CEdA9wemArdJeq2ZLUmspxpmAd+VdGx2f5qkNwPfwLOCOeeqKS0WD6tkyNfBhIMKd0q61szml5QpHfL1oqQtKtVbqTP7FLA98OjACjN7Ort69hbg8tQn4pxz0eID6HNmtscw258EppXcn5qtK7UI+LOZ9QCPSHqI0Lm9M7YR1WJm35A0EbgRGE2Iv2uA88zswro2zjnX/Ao+5KvSMINbgKPKV5rZP4ADCT8IzjlXHfmd2roT2EHSdpK6gCOAa8vK/JJwVBZJkwmn9Rdu5DPIjZl9DphM+DHYG5hiZl+ob6uccy0hPhZPljSnZDmurKaqDPmqdGT2K2yYOjE8L7OnJO0HvK3STpxzbkRyGpFvZr2STgCuJ0xndYmZzZN0FjDHzK7Ntr1N0nygD/ismT2fTws2nqT3AwcBW5AdiBhIAmBmh9avZc65phcfiyudJYuRPORr2M6smT0GPDbM9qeAy0bSUuecG9bARN15VWd2HXBd2bozS24b4TqAwl0LIOlcwlRhtxAuBvMLb51ztZFvLK7KkK8C5Zlzzrn1FT0feA19CDjSzGbXuyHOudaTYyxeO+SL0Ik9gg2Hs/4SOBL4UeyQr6buzFpnO71T4qdgVE98Puu21d1JbdHK1UnlSSivnrS2WE9aHu688zyvX3nCf3ttaQnrlJgTXKO64gunlAUssXz/mPjy1tme1paOtNfREt4j9SXmp680ItU7swPagHvq3YgRaWvDxo6OL5/wGVJiLEv+RU757Pf2pdXd05NWfnX8b4L1p8WEqs4g2tlZuUypUaOiiyrlcwXY6Pi6ASwhDvd3Jcbh1LjdlvJbmVR1ZANyqqZKQ76aujPrnGtwBZ+ou4ZmAUfj03A55+qh4EO+ataZlTSNMJXXloQ+/iwz+05ZmU2BS4BXAquBj5rZ/dm2TwPHZo+9D/iImSUe7nTONRL5kdkBk4CjJB0MzAXWO6xnZifGVhQZiycCPwG2IfxOnGdmP8q2nQO8Myv6FTP7+UiekHOucRQ9FkcdjJZ0s6RJg6zfRNLNkfvqBT5jZjMI08ocX54bHfh34B4z24UwRuw72X62Bk4E9jCz1xAOTR8RuV/nXCOKnQqm4EE2JzMIwwy6CTPMvLZkeU1iXTGx+Hhgvpm9jnBF8TcldUl6JyEL5K7AXsCpkjydrnPNrAFiceyR2f2BwQaPjAbeHFNBNvPBU9ntlyQ9QJhbrHSi3BnA2VmZv0maLmnLkraOkdQDjCVc0euca1ryYQYZMzsgx7piYrEBExTm/hoPvEDoBM8AbjOzXqBX0lxgJnBVXu1zzhVN8WPxsJ1ZSbuX3N1F0gsl99uBt7PhlAoVSZoO7Ab8uWzTvcC7gd9L2hPYFphqZndJOg94HFgF3GBmNwxR93HAcQCjuyamNs05VySJ15O5NMPE4gsISSUWAxOA95tZv6R7gS9K+ibhoMIBrN8JHqh3XRzu9AO3zjW8gsfiSkdm57Du4PFgncdVwKdSdihpPPDfwMlmtqxs89nAdyTdQxgXezfQl42lPQzYDlgC/ELS0Wb2k/L6s3zsswA2Gb91a5yAdK5Z+Td4rews1fGEo6NG6ET+p5k9PcL6hovFbycMaziQcA3DjZJ+b2Y3SHoD8CfgWeB2wtXG6ymNwxPHbOXvonONruDf4kpjZrcjBDIRUihuV7JsDWxiZpfE7kxSJyF4/tTMri7fbmbLzOwjZrYrYczsFMLkPW8FHjGzZ7NJdK8G3hi7X+dcAxqYqDtmaXKS9gUWEOZjXEW4QPYDwMOS9hlBfcPGYuAjwNUWLAAeIcsGaWZfNbNdzexgwm/DQyN5Ts65BtEAsTgmAxjkMGtZNvbqYuABMzt/iDKTgJVm1k2YueA2M1sm6XFgb0ljCYH8IMJRY+dcEyv6FbQ1dB5wBfAJM+sHkNQG/AD4Jgn/3MfEYsKQroMIQ762BF4FLJTUDkwys+cl7QLswuBn7ZxzTaTosTh6ai5JU4G3UJIXfMAwAbHUvsAHgfuyYQQQZi/YJqvjB8DOwGWSDJgHfCzb9mdJs4G/Ei5CuJvsFJZzrokVPIDW0K7AMQMdWYBsDOv5hHiYIiYWfwW4VNJ9hKOv/2Zmz0kaTejgAiwDjs4uBnPONbOCx+KozqykDxDmf+0ljJMqfVoGVOzMmtkfqJBoxMxuJ6QtG2zbF4EvxrTXOeeazFLC8K4Hy9YPXEcQLTIWLwbeNsj61YQxu845VxixR2bPIpzK+oKZJebsq5/+rjZWbDM2unxbb/y/Hh0rxyS1pXNZWvn2pauiy2p5fFkAutPS39KX8JZXM11kYnra1DSKNiY+1WH/uLQ0in3j0trSOy7+ufZ3pY0C6utKG9dkCdUnn4oqv4Z+Y+trXlcCF0s6jXDxFYQjrOcQhh8UlnW20/2yCdHllRCH29akHRRu6077+UpJ5Zw6GK9tVVo6W72UEENWr0lrTG/C69iemFY8IT0tkJT6uG+TtN/V3glpbekdF59ytndMdeNwf3t8+ZSYHavosTj2F3NL4KJG6sg655pAC1zcFek0wtHUS1gXt3uA7wOn16tRzrkWUfBYHNuZvY6Q7WVhFdvinHPrtE52r4qyi2JPknQGYYYZgL+b2co6Nss51woaIBbHdmZvBM6R9GrC/K/lecEHm9rFOec2TsEDaK2Z2UpJjwzcrnd7nHMtouCxOLYz+1/Z338fZJsRsoE551yuVPCsM7Uk6WTgFMIc30haTLj49ttmqYPVnXMuXtFjcVRn1qwaw4mdc64C76IBIOkbhPSw5xKybgHsA5wJbEUYU+ucc9VR8FiceHm4c87Vhqz4V9DW0LHAsWY2u2TdzZIeJJw5886sc64qGiEWRx1xVfD/JM2TtFLSK7L1p0t6X3Wb6JxrWQVPoVhjc4dY52fOnHPVVfBYHBsETwI+T8i6VdraJ4ET8m6Uc84B666irbQ0v8uB4wdZ/0ngxzVui3Ou1RQ8FscOM/gE8HEz+7Wk/yhZ/1fg1fk3yznnin9qq4ZGAUdJejtwR7ZuL+DlwE8lfXegoJmdWIf2OeeaWNFjcWxndlvg/kHW9wBpKTiccy5WwQNoDe1EOHgAIR4D/CNbdi4p56+Ycy5/BY8ssZ3ZhcDuwGNl698BzM+1Rc45B9AAFx3UipkdUO82OOdaVAPE4tjO7HnABZLGEsbM7iPpg4QraD9arcZtrL5RsPQV8VPgKiFZb8fKtHd29ItpE0eMeTY+D3fnC11JdbetWJ1UXt0JOcRTp7tMyH1uHYnTGY9Ke136EvJ292ySVveaiWlt7xkXf01Pz9jEHN9pTac/5aOb96VIBQ+grrLe0eKFneK/W2298XV3vZT2AelckTZZZsqklNae9j1sX5PWlq4X4k+CdixdlVQ3PQkvelval7xvfPx7D9AzaXR02VWT438nAVZtntb27knxZXs2Sfss9o5JK29dCR2U9sTAeWlMA9KqrLXYeWZ/JKkD+BowlnDBwWLgRDP7eRXb55xrZQUPoLUkaUtgX2ALyv5tMLP/rEujnHOtoeCxOPqYi5n9EPihpMlAm5k9U71mOedc8U9t1Yqko4GLCGfGXmT9nxYDvDPrnKuaosfi5KQJZvZcNRrinHMbKHgAraGvAt8AzjKzhHPCzjmXg4LH4qjOrKTNCMH0IAY/xbVJ/k1zzrW0BrjooIY2AS71jqxzruYaIBbHHpm9GNiNkDRhMYXvozvnmoJHmgE/Bd4JfK/eDXHOtaCCx+LYzuxBwMFm9udqNsY559ZT8ABaQ6cAv5R0EHAfYY7vtczsrLq0yjnXGgoei2M7s88Ay6vZEOecKyWKf2qrhv4VmAk8B2zPhheAeWfWOVcVjRCLYzuznwPOkvRhM/NOrXOuNgoeQGvoC8BnzOxb9W6Ic64FFTwWx3ZmPw9MB56R9BgbnuLaJed2OedaXQNcdFBD7cC19W6Ec64FNUAsju3Mzq5qK5xzbjAFD6A19CPgA/hwAudcPRQ8FsdmAPtytRvinHMbKHgAraGxwLGS3g7MZcOzYyfWpVXOudZQ8FiclDRB0oHADMLTmmdmt1ajUXnpH2Us36GncsER0Oq0HM+jnm9PKt89viu67PhRaW3pejEtV0b7yu7osupNzH2u+Hzm1pn2GvaNS8vb3TMxvvyqzdJew9Wbp+Vt706Yubl3XFqU6RudmBN8VMJ7mpoTvAKlfZya2c7A3dntncq2Ffpnpm+s8eKu8dPjqjc+no16Ji0mdC1Ji5UkfG0tser2NWltHzMhvvzoF9JiX/uavuiy/e1pT7R7YlqsXLlFfP0rtk6qmjVbpfUHJkyJv0Ro6oSXkurecuyypPKbda2MLju+fU1S3V+PKFP0WBybNGFr4Brg9YR5ZgFeLmkO8C4zWzzkg51zbiSMgnfTasfMDqh3G5xzLaoBYnHsv0DfBfqA7c1smplNA3bI1n03pgJJoyX9RdK9kuZJ2mDogqRtJd0kaa6kWyVNzdYfIOmekmW1pH+JbLtzrkHJ4pZWIGlLSWdJmi3pF5K+JGmLEdQTE4uPkfRsScw9Nlu/raS/ZuvmSfpEHs/NOVdsRY/Fscf/Dwb2N7NHBlaY2UJJJwI3RdaxBjjQzJZL6gT+IOk3ZnZHSZnzgMvN7LJsSMPXgQ+a2S3ArrA2te4C4IbI/TrnGlWLdFQrkbQv8FvgaeD2bPXRwCmS3m5mtw/54A3FxGKAn5vZCWXrngL2MbM1ksYD90u61s/OOdfkCh6LUwazDPZUop+emRnrEi90Zkv542cQMt0A3AL8cpCqDgd+Y2bxA0iccw2pVY66RjgPuAL4hJn1A0hqA34AfBN4Y2xFkbF4qMeWDqAfRfzZPedcAyt6LI4NRDcB35M0bWCFpG2AbxN/ZBZJ7ZLuIWQUu3GQ9Lj3Au/Obr8LmCBp87IyRxCC+lD7OE7SHElz+l5aEds051wRWeQSQdJMSQ9KWiDp9GHKvUeSSdpjI1ufp12Bbw50ZAGy2+cDu6VWFhGLAd6TDfmaXRb7p0maCzwBnDPYUVmPw841mRxjcTXEdmZPBMYBCyU9liVO+Hu2LnpKGDPrM7NdganAnpJeU1bkVGA/SXcD+wFPEsblAiBpK+C1wPXD7GOWme1hZnu0TxgX2zTnXNHEBs+IACqpHbgQOIRwBuhISTMGKTcBOAkYrHNXT0uB7QZZvx2wJLWyiFj8v8D0LCHOjcBlJY99Ilu/PfBhSVsOUr/HYeeaRY6xuFqiOrNm9gSwO/AOwumu84BDzGx3M1uUulMzW0IYRjCzbP1iM3u3me1GSKE7UHbA+4BrzKw682055wpDCUuEPYEFZrYwO1V+JXDYIOW+ApwDrN641ufuSuBiSR+QtF22HA1cxDBnqioZJhY/b2YD8/tcRJjJpvyxi4H7gTePdP/OueLLORZXRfR4JwtuNLPvZcvvUnYkaYqkSdntMYSLyv5WVmZyNg4M4AzgkrJqjmQjArdzrsHEHw2YPHBaO1uOK6tpa8Jp8QGLsnVrSdodmGZmv67CM9lYpxEyMV5CuAB2AaGTeRUw5JCJwUTG4q1K7h4KPJCtn5o9BkmbAm8CHkx/Os65hlLwIV/RF4BlU2GdQjhFByG4nW9m10RWsRVwWXa6rw24ysx+JeksYI6ZXQvsD3xdkgG3AceX7H86MA34v9g2O+caW8JFB8+Z2YjHuGb/RJ8PHDPSOqopO5p8kqQzgFdmq/8+wgthY2LxiZIOBXqBF1j3uuwMfDOL0QLOM7P7RvzEnHMNIa8LwEqGfB1MOKhwZzYjyvyycklDvmKTJnwG+BpwOXBptnof4GeSvmBm51Wqw8zmMsiFCmZ2Zsnt2YSjD4M9/lHKjqQ455pcfllnniT8MzxgarZuwATgNcCtClnpXgZcK+lQM5uTWys2UtZ53ajOY2QsPoNwdqy8zI3ALhuzf+dcA8ovFq8d8gUgaWDI1/yycgNDvj4bU2nskdlTgRPM7Icl6y6R9BfgLMIY2sIZNaqHHV/xVHT5zvb4lH6retPSBT75wsSk8kvHjI8ua21p6QLHt6eNbOl8KT6NYlt3/GuYqn9UWvrHnnGJKWc3i69/5RZpr+HqLdL+re3dLH5YeNeE+HTDABPGpKU6HNsV35ZxnWlteXy4jflOwn0nsIOk7Qid2COAo9buymwpMHngvqRbgVPr3ZGVdAjwfWAXM1tWtm0iYQaYj2edzELqGtXL9Fc8E11+dW/89/YfXZsltaVvdFpMSEpnm1Yz7WlfFfo74mdB6+9Ie54dq+NjX3/i78eaSWnlV7w8vvyaqWkv4rStn08q/5rN4vsPrx73ZOVCJV7ZFf+dAHhZe3z6283a0y4rqpjONi0WT1bIDjtglpnNKrk/2JCvvUorKB3yJSnXzux4wkUC5W7JtjnnXP5y6syaWa+kEwgzobQDl5jZvLJT60V0AnBueUcWQgdc0jnAyYQZB5xzrjoKPuQrtjP7S0KygrPL1r8HKOqPgHOuweU5UbeZXQdcV7buzCHK7p/fnjfKLqxLJDOYm8lmfnHOuWrJMRZXZchXbGd2AXC6pANYl0px72w5X9LaYGtm50fW6Zxzwyt41pkamMLwo9UMKE8s45xz+Sr4kK/YzuwxwIvAjtky4EXgIyX3jXB42DnnNlrRUyjWwCLC0dmHh9i+C+sf1XDOudzlFYurNeQrqjNrZoNlnnHOueqpc0aZgvg18BVJ15nZqtINksYSLsAt4ry4zrlmkXMsrsaQr8RLO51zroa8M/tVwvUKD0m6gHXJDXYmXBwmwrSJzjlXPQWPxSlJE94FHABsQVnmMDN7X87tcs61OOHDDMzsGUlvJEzP9TXWTRZlhNN0x5vZ0/Vqn3Ou+TVCLI5NmvBN4FPAH4GngepNJuqccwMKHkBrwcweA96RpY/dnvDb8rCZvVjfljnnWkbBY3HskdkPA+81s/+pZmOcc24tA/UXPIJWkaTtzOyRgftZ5/XOIcoKmGpmTwy23TnnRqwBYnFsSpGVrBur5ZxzNSGLW5rU7ZIulrTPUAUkbSrpk4RUkIfVrmnOuVZS9Fgce2T2bOA0Sf9qZr3VbJBzzq3VvB3VGDsREiL8WlI/cBewGFgNbArMIFwI9hfgZDO7vl4Ndc41uYLH4tjO7A+BfwaelPQQsF7iXzM7MO+G5WGTjtUcuMWD0eXHtsXnee6x+FzWAA9usmVS+du7pkeXfal/UlLdYWq3eGNGxefK7liVVnfKF6RvVHxucoDuCWnlV02Jf56rXjbcPPYbspetSSo/ZdPl0WVfNv6ltLpHxdcNsFnXiuiykzvT6v5dhe1NfNS1IjNbAnxW0pnAO4E3AdsCY4DngMuA683s/ro1MsKotl6mT3ghuvxLPaOiyz47bkJSW/qWJ8anKrL2+HgD0JaQOL69O63u/oS2WFpYpXdsWlv6xsR/6TvH9FQuVGLS6FWVC5WY0hUfW1/WsTSp7pcnlp/WHv+bs2l7woclUtFjcWxn9geEQPpbwgVgBX9azrmm4JGGbH7Z2dninHO1V/BYHNuZfT/wLjO7sZqNcc65tZp7PKxzzjWGBojFsScMnsVTJjrnas0ilxYiaYykrQdZ/+p6tMc51wIKHotjO7NfBM6SlP9ADOecG8TARN1FvoK21iQdDjxMuChsrqS9Sjb/uE7Ncs41sUaIxbHDDD4LTAeelvQ4G14AtkvO7XLOObAW6qnG+TzwejN7WtLrgcskfc3Mfsa67GDOOZevgsfi2M6sX3jgnKu5VjrqGqlzIH2tmd0l6S3ANZK2p+UGXDjnaqXosTiqM2tmX652Q5xzbj0G8sTZ5Z6RtIuZzQUwsxckHUyYpsvPkDnn8tcAsTj2yCwAkg4kTNRtwDwzu7UajXLOOcCPNW7og8B6iWvMrBs4UtIF9WmSc67pFTwWR3VmsytnrwFeT8hAA/BySXMIU3YtHvLBzjk3QkU/tVVrZrZomG1/rGVbnHOto+ixOPbI7HeBPmB7M3sEQNIrgJ9k2w6vTvOccy3LKPxFB7Ui6ZIhNhkhve0C4Od+YME5l7sGiMWxndmDgf0HOrIAZrZQ0onATVVpmXOu5RX9aEANTQHeDPQDA+lrX0OYweAu4N2E6RPfbGb31KWFzrmmVfRYnDJmdrCnUuinN659DfuMezi6/OZtaXmbU8wYnZZzYnz7muiy1/fvnFT3S2ySVL5vVHw+887laYm72xIGlfd1JVVN9yZpMxWtmhL/cbaXxb8/AFtPWZJU/pUTn4suu82Y+Lz3AFt1prVlSkd8fvIpHcuS6q6o0BGmpv4ILAc+ZmYrASSNBX4I3Au8A7gc+CZwUL0aORhD9PTHx5Du/vifJetP+46rN7F8yuevP6nqqs6jZm1ptVtbwhNNbXjid1gJr2Nfb9rvzYqetB+R5b2josu+1D86qe6X+tPasqJtZXTZsdZTuVCqgsfi2E/CTcD3JE0bWCFpG+Db+JFZ51wVNMJE3TV0EnDWQEcWILv9VeDT2UVg5wC71qd5zrlm1QixOLYzeyIwDlgo6TFJjwF/z9admLJDSe2S7pb0q0G2bSvppiyzza2SppZs20bSDZIekDRf0vSU/TrnGoxZ/NL8xgNbDbL+Zdk2gGUknG2rEIvfIumvknqzrGOl2zwWO9dKGiAWx84z+4Sk3YG3Ajtlqx8ws9+NYJ8nAQ/AoOe6zwMuN7PLsmnAvk6YigbCKbSvmtmNWVrdxJM6zrlG0yJHXWNcA1ws6TTgzmzdG4BvAFdn9/cEHkqoc7hY/DhwDHDqINs8FjvXYooei6P/izczA27MlhHJjrS+k3Bq7JRBiswoWX8L8MvscTOADjO7MWvL8pG2wTnXQAoeQGvoE8D5hBlkBuJ2L3AJ6zqcDwAfj6msUiw2s0ezcv1lj/NY7FwrKngsHnaYgaRDJD0qaYP/3CVNzLYdnLC/bwOnMfR/8vcSrsoFeBcwQdLmwI7AEklXZ6fFzpU06BUFko6TNEfSnKXPFzxlhXNuWEUfp1UrZrbSzD4BbAbsli2bmdknzWxFVuaehJkMvs3wsXgoUbG4NA6vXrI6cRfOuaIpeiyuNGb2BOBcM9vgEmUzW0q44ODkmB1J+ifgGTO7a5hipwL7Sbob2A94kjC/bQdhWppTCafWXkE4BbYBM5tlZnuY2R4TN4+/gtY5VzAG9Fnc0iLMbIWZzc2WFSOpIzIWDyUqFpfG4dGT0q7yds4VTAPE4kqd2V2A4cbF3gy8LnJf+wKHSnoUuBI4UNJPSguY2WIze7eZ7QZ8Llu3BFgE3GNmC82slzD8YPfI/TrnGlTRjwbUkqQtJZ0labakX0j6sqQtR1BVxVg8DI/FzrWgosfiSp3ZKQx/GsqAzWN2ZGZnmNlUM5sOHAHcbGZHl5aRNFnSQJvOIIwHg3DBwyRJU7L7BwLzY/brnGtgBb+CtlYk7UvI8nUUsIqQ9esDwMOS9kmpKyYWD8NjsXOtqOCxuFJndhHh6OxQdiEMBRix7EjDodnd/YEHJT0EbEm4OAEz6yOc1rpJ0n2Eac9+uDH7dc4VX9GPBtTQecAVwI5m9kEz+yBh/OqVhEQJG600Fkt6g6RFwHuB/5I0DzwWO9eqih6LK81m8GvgK5KuM7P10mNl2WfOysokMbNbgVuz22eWrJ8NzB7iMTcyfMfaOddMjMJfQVtDuwLHmNnaM2Vm1i/pfODukVY6TCy+E5g6xGM8FjvXShogFlfqzH4VOBx4SNIFwN+y9TsTLg4T8LXqNW/jjKaPHTriZ46Z3D4mumzn4JMpDGnL9rSUoysmLIgu+8jkqJEea929NO2CjNUJKQD7u1LTS8aXTcz+R/ektG9f7xbxKQBfPnlpUt07THw2qfyO456OLju1K+2z9bKOJUnlp7THX2c0pS3hDa0gZJ0peAStnaXAdsCDZeu3A5bUvDUJevrbeHbV+MoFM8tT4s2KlIzsMCoxY7n64uNZShrWkUjIcE5bT9r3Jsev7Qba16S1pX1l/Gves6Izqe4XV8b/xgM8NWZidNlNO+PTzQKMbUtLid6e0JvsscQPegWNEIuHjQRm9oykNwLfJ3RaBz5lBlwPHG9m8b+6zjmXwqfjH3Al65Im/Clbty9hRpkr6tYq51xrKHgsrvhvrZk9BrxD0qbA9oQO7cNm9mK1G+eca21FPxpQQ6cRYu8lhLgtoJtwoOH0OrbLOdcCih6LUzKAvci6NIrOOVddDTBOq1bMrBs4SdIZwCuz1X83s7Rzm845l6oBYnHagCPnnKuZ1ph2ayiSro0oA4CZHVqhqHPOjVDxY7F3Zp1zhaX+YgfQKnu+3g1wzjkofiz2zqxzrpis+leIF5mZfaTebXDOuUaIxd6Zdc4VV8FPbTnnXEsoeCyulAHMOefqxyKXCJJmSnpQ0gJJG8wAIOkUSfMlzZV0k6Rtc3oWzjnX2HKMxdXgnVnnXGHJLGqpWI/UDlwIHALMAI6UNKOs2N3AHma2CyET4TdyfjrOOdeQ8orF1eKdWedccZnFLZXtCSwws4XZNFdXAoetvyu7pWSqqzsYIp2rc861nPxicVX4mFnnXDEZKVlnJkuaU3J/lpnNKrm/NfBEyf1FwF7D1Pcx4DfRe3fOuWaVFovroqk7swb0JZRfYz3RZfsT39mVif+xrOiPz0/ea+1JdSs+9TUAKdX3J36iUk4NpNbdn/ayoI7493R0R1oy8wmdq5PKj23rjm+L4j+3kJbjO1XK960SkXTa6jkz2yOX/UpHA3sA++VRX6vr7W/nmeXjo8uvWtMZXbZ9edqXvHN5WvBTwgc6pexItK+J/952rEqru2N19Xoq1p52ArgjIQ1I+0tp7/+y5WOSyi8ePTG67LiO+JgN0FnFD0w3S3OtLzEWV65Pmgl8B2gHLjKzs8u2nwIcC/QCzwIfzbLRDsmHGTjniiu/U1tPAtNK7k/N1q1H0luBzwGHmtmaXJ6Dc841upxicbWuX/DOrHOuuPLrzN4J7CBpO0ldwBHAehm2JO0G/BehI/tM7s/FOecaVcGvX2jqYQbOuQZmoL58Tm2ZWa+kE4DrCae2LjGzeZLOAuaY2bXAucB44BdZmtjHPU2sc67l5RiLqdL1C96Zdc4VV47jtMzsOuC6snVnltx+a247c865ZhIfiytdjBst5foF78w65wqqvlO9OOecg8RYXOli3NTrF/aLuX7BO7POuWIyvDPrnHP1lm8sXnv9AqETewRwVGmBkusXZsZev+CdWedccRV8bkPnnGsJOcXial2/4J1Z51xh1TM9onPOuSDPWFyN6xe8M+ucKy7vzDrnXP0VPBZ7Z9Y5V0wG9Bc7gDrnXNNrgFjsnVnnXEH5bAbOOVd/xY/FTd2ZfclG8X+rto0uP6EtPqF1u9JGQ/+jZ1rlQiX+tHT76LILnp2cVHfb8/G5zwE6l8XnM+98Kalq2hImYm7vSMurDmnlV43pii771NhNkuoe1d6b1pa++Pfo6a60tkxoX51UfmJ7fLL01LrhH8NvLngAdZX19YllL42JLt+/Kv5nafSytCSWnS+lfZ7aUr62Vb5Ysb07vmznyrTGdKyuYuOVFod7lyeUHZdW9+pl8TEe4LnR46LLju1MeIOAUUkfLmhL6HP0WGrXbkHlIgWPxU3dmXXONTAD+nw6A+ecq6sGiMU17cxKehR4CegDessn1pW0KXAJ8EpgNfBRM7s/5rHOuWZjYMUOoI1MUjswB3jSzP6pbNu3gAOyu2OBLcxsUrbtHOCd2bavmNnPa9Ni51x9FD8W1+PI7AFm9twQ2/4duMfM3iVpJ+BC4KDIxzrnmk3BT201uJOAB4ANxqmY2acHbkv6FLBbdvudwO7ArsAo4FZJvzGzZbVosHOuTgoei9MGHFXfDOBmADP7GzBd0pb1bZJzri4GrqCNWVwSSVMJR1cviih+JHBFdnsGcJuZ9ZrZCmAuMLM6rXTOFUIDxOJad2YNuEHSXZKOG2T7vcC7ASTtCWxLyNsb81iyxx0naY6kOS+90JNz851zNWUWt7hU3wZOo8JlS5K2BbYjO8hAiNEzJY2VNJkwFGGDq1tL43DfSytybbhzrg4KHotrPczgTWb2pKQtgBsl/c3MbivZfjbwHUn3APcBdxPGyMY8FgAzmwXMAtjuteP9V865RuYd1dxJ+ifgGTO7S9L+FYofAcw2sz4AM7tB0huAPwHPArezLkavVRqHR71ia38TnWt0BY/FNT0ya2ZPZn+fAa4B9izbvszMPmJmuwIfAqYAC2Me65xrNpFHAgoeZAtoX+DQ7KLaK4EDJf1kiLJHsG6IAQBm9lUz29XMDibMf/dQNRvrnKu34sfimnVmJY2TNGHgNvA24P6yMpMkDUwEdyxhbNaymMc655qMAf39cYuLZmZnmNlUM5tO6KzebGZHl5fLLsLdlHD0dWBdu6TNs9u7ALsAN9Sk4c65+miAWFzLYQZbAtcoTKDcAfzMzH4r6RMAZvYDYGfgMkkGzAM+Ntxja9h251w9+FHXmpF0FjDHzK7NVh0BXGm23pvQCfw+i8XLgKPNLG32d+dc4yl4LK5ZZ9bMFgKvG2T9D0pu3w7sGPtY51yTK3gAbXRmditwa3b7zLJtXxqk/GrCjAbOuVZS8Fjc1BnAnu8ex4+f3Du6fFf7Btcx5OaFVWOTyj/13MTosu2LRifVPX5xWgrAUS/Gf4g7V6WdZlDCS27tSVXT9VLaKJqOVfHlV62akFT3A0vT3qOFEzaPLjt2dGIaxc60A2mjO+LLp6bthT8PvckM66ved9LVSF8btjQ+jWj7yvjvYWdC6lOAzsSJFdp64mNfYobzZO0JbelITGfbvib+e2aJ6WlTy3eOig/0KalvAXqXpf2IrBwzKrrss13jk+oe3Z4221JHWx1jYQPE4qbuzDrnGpzPIeucc/VX8FjsnVnnXHEV/NSWc861hILHYu/MOueKycxnKnDOuXprgFjsnVnnXHEV/GiAc861hILHYu/MOucKywp+NMA551pB0WOxd2adcwXl2b2cc67+ih+LvTPrnCsmo/BX0DrnXNNrgFjsnVnnXHFZsU9tOedcSyh4LPbOrHOukAywgh8NcM65ZtcIsdg7s865YmqArDPOOdf0GiAWe2fWOVdcBT+15ZxzLaHgsVhW8CvUNoakZ4HHylZPBp6rQ3MG420ZnLdlcM3Ylm3NbMpgGyT9NttPjOfMbGYO7XE5GyIOQ3N+nvPgbRmct2VwebRlyDgMjRGLm7ozOxhJc8xsj3q3A7wtQ/G2DM7b4ppJkT5D3pbBeVsG520pnrZ6N8A555xzzrmR8s6sc84555xrWK3YmZ1V7waU8LYMztsyOG+LayZF+gx5WwbnbRmct6VgWm7MrHPOOeecax6teGTWOeecc841Ce/MOuecc865htW0nVlJMyU9KGmBpNMH2T5K0s+z7X+WNL3G+99W0k2S5kq6VdLUkm3nSLo/W96/ke24RNIzku4fYvumkq7J2vEXSa8p2fZpSfOydlwhafRGtmWapFskzc/qPale7ZE0Oqv/3qzOLw9SZtD3SNIBku4pWVZL+peRtiWrs13S3ZJ+FduObNs2km6Q9ED2uk7fmHZkdT4q6b7suc0ZZPtw79Gwj3WtJSL+SNJ3szg5V9Lutdx/Vmb/7PM6T9L/ZesqxocRtCUm/n0gex3uk/QnSa8r2TZJ0mxJf8u+7/tUuS0TJf1vyWvwkZJtef5GxcTiYyQ9WxJzj83WbyvpryXv3yc2pi1ZncPF4rdk++uVdHjZtmrE4uHa8q2S1+MhSUtKtuX2/jQMM2u6BWgH/g68AugC7gVmlJX5f8APsttHAD+v8f5/AXw4u30g8OPs9juBGwnZ2cYBdwKbbERb3gLsDtw/xPZzgS9mt3cCbspubw08AozJ7l8FHLORr8tWwO7Z7QnAQ4O8LjVpDyBgfHa7E/gzsHfMe1RWZjPgBWDsRr42pwA/A341yLYh2wHcChyc3R6/se3I6nkUmDzM9kHfo5jH+tJaS0T8eQfwm+z7uDfw5xrvfxIwH9gmu79F9rdifBhBW2Li3xuBTbPbh5S+HsBlwLHZ7S5gUpXb8u/AOdntKVmc6yL/36iYWHwMcMEgj+0CRmW3x2fx5+Ub+T4NF4unA7sAlwOHl22rRiwesi1l5T4FXJLdzvX9aZSlWY/M7gksMLOFZtYNXAkcVlbmMEJwAJgNHCRJNdz/DODm7PYtJdtnALeZWa+ZrQDmAiPOpmFmtxGC0FDWtsPM/gZMl7Rltq0DGCOpAxgLLB5pO7L6nzKzv2a3XwIeIHRSa94eC5ZndzuzpfxqyKHeo1KHA78xs5UjbUt2pPWdwEVDFBm0HZJmAB1mdiOAmS3fmHYkGO49cm6tiPhzGHB59n28A5gkaasa7v8o4Gozezwr/0z2NyY+pLalYvwzsz+Z2YvZ3TuAgbNBEwkd84uzct1mtqSabSE83wnZ7+J4wuvYS/6/USN+rbPXYU12dxQbeba5Uiw2s0fNbC7QX/a43GNxxO9CqSOBK7Lbub4/jaJZO7NbA0+U3F/Ehl/UtWXMrBdYCmxew/3fC7w7u/0uQtDYPFs/U9JYSZOBA4BpObVrMGvbIWlPYFtgqpk9CZwHPA48BSw1sxvy2ml2CmY3wn/hdWlPdgrnHuAZ4EYzG7ItrP8elTqCdUFkpL4NnEZZgIxox47AEklXZ6eizpXUvpFtgfBDcoOkuyQdN1x7St+jyMc6VyomVlbTjsCmCsN37pL0oYENEfFhxIaJf6U+RjhqDbAd8Czwo+y7fpGkcVVuywXAzoSDBvcBJ5lZP1X4jYp8rd+TDcGYLWlayWOnSZpL+BydY2Ybc9Dl2wwfi4dSjVgc1RZJ2xI+HwMHPGrdhyiEZu3MNoJTgf0k3Q3sBzwJ9GUdtOuAPxE6SbcDfVVsx9mEoyH3EE5V3A30SdqUcNRkO+DlwDhJR+exQ0njgf8GTjazZfVqj5n1mdmuhI7YnioZ+5kZ9D0qeR5bAa8Frh9pGyT9E/CMmd01TLGh2tEBvDnb/gbCsJZjRtqWEm8ys90JpzmPl/SWsu2DvkeRj3WuSDqA1xOOgL0d+IKkHSEqPoxIhfg3UOYAQmf230rauTvwfTPbDVgBbHAtRs5teTtwDyHe7gpcIGmTavxGRbzW/wtMN7NdCKfQLyt57BPZ+u2BD4/0LFFkLB5KrrE4sS1HALPNrA+gDn2IQmjWzuyTrP+fyNRs3aBlstPWE4Hna7V/M1tsZu/OAtPnsnVLsr9fNbNdzexgwniih3Jq1wbMbJmZfSQLJB8ijI1aCLwVeMTMnjWzHuBqwniujSKpkxA8f2pmV9e7Pdk+lxBO388sWz/ke5R5H3BN1p6R2hc4VNKjhOEoB0r6SWQ7FgH3ZMNZeoFfEn7wNkp2FHzglOs1hGEzpduHeo8qPta5MjGxupoWAdeb2Qozew64DXhdaYGh4sNIVIp/WZldCKeWDzOzgd+kRcCikiOWs9nI73pEWz5CGIJhZraAcM3CTlC936hhYvHzJcMJLiL8A1L+2MXA/YRO5UhUjMXDyDsWp7Rlg7ODtexDFEWzdmbvBHaQtJ2kLsKbfW1ZmWuBD2e3DwduNrO8MkhU3L+kyZIGXv8zgEuy9e0Dp7KzoLYLkNvp/XIKV8h2ZXePJYy1WUY4nb93dqpCwEGEcVUbsy8Rxnw9YGbn17M9kqZImpTdHgMcDPytrMyg71GJ0nFKI2JmZ5jZVDObTvic3Gxm6x1xHqYddxKOkE7J7h9IuJhlxCSNkzRh4DbwNsIPRGmZQd+jmMc6V+Za4EMK9iYMH3qqhvv/H+BNkjokjQX2Ah6IiQ+pIuPfNoR/1D9oZms7IGb2D+AJSa/KVh3ERnzXY9pCiLkHZeW3BF4FLMz7NyoyFpeOoz6ULPZLmpo9huzs3ZuAB0fSjphYPIxcY3FsWyTtBGxKOPo6sK6mfYjCsAJchVaNhXCV7EOEWQU+l607Czg0uz2acJX4AuAvwCtqvP/DgYezMhex7orM0YQvwXzCBQC7bmQ7riCMMe0h/Pf4MeATwCey7ftkbXiQEEQ3LXnslwlB5X7gxwNt3Ii2vIkwpnIu4fTVPdnrVPP2EL7gd2dtuR84M/Y9yrZNJxxBasvxM7M/2VWrCe04OHsO9wGXAl0b2YZXEMZc3QvMK/nsVnyPhnqsL627RMQfARcS4uR9wB613H9W5rOEeHs/4XT7kPFhI9sSE/8uAl4s2T6n5PG7AnOyx/+yNDZWqS0vJ3SC7steg6Oz9Xn/RsXE4q9nMeVewpHbnbL1A/Hv3uzvcTl9bvZn8Fj8huxztIJwJndeyWNyjcWV2pLd/xJwdln5XN+fRlk8na1zzjnnnGtYzTrMwDnnnHPOtQDvzDrnnHPOuYblnVnnnHPOOdewvDPrnHPOOecalndmnXPOOedcw/LOrHMbSdKjkk6tdzucc865VuSd2YKStKWk70j6u6Q1kp6U9BtJ76h324pE0nRJJmmPiLKfk/RHSSsk+Zx0zjnnXBPwzmwBSZoO/JWQG/sMwqTSbwV+Dfygfi1reKMIk/x/u87tcM4VkKRLJf2qxvvcVNLTkl5Zy/266pD0C0mfqXc7Wo13ZovpP7O/e5jZVWb2oJk9YGYXEDq2QEh9KOkaSS9ly9WSppZs/5Kk+yV9ODsVvkLSjyR1Sfp/kp6Q9Lyk80vSpQ6cNv+SpJ9IWi7pH+Wn0RP2fUR2dPklSb+UNLmsno9Imi9ptaSHJH26rC0m6bgsQKyQtFBSaVq/R7K/d2Zlbx3qRTWzM83sm4RsM1Ek3SrpB9lR8hez5dzSNmZGS/ovScskLZL02bJ6TpE0N3sOT0q6aCCFY7Z9oqQfS3omey0WSjq5bPusbPtLkv4v5mi0c67w/h24zsz+PrDCz8zFy2L0BcNsf4uka7PX0CQdM0zZKZL+M/sNXJP9k3GTpINLylya1VO+7JoVOQv4nKSJeT1HV5l3ZgtG0mbATOBCM1tevt3MlmTl2gh5xbcEDsiWlwO/lKSSh0wHDgP+CXg38F5CPvQ3AG8DjgU+BbyrbFenEPJf7w58EfiapHePYN/vz+p+G7Ab8NWS5/px4GvAmcDOwGeAfwP+X1lbzsz29zrg58AlCjnMAfbM/s4EtsqeY94+QPiu7AP8K3AccHJZmU8T0hjuDpwDfEPSPiXb+7PHvBo4Kmv390q2/wfwWsL79Crgo4R0uQN51H8NbJ1t3w24DbhZ6+csd841EEljCTH44pJ10/Ezc3kaT0iTexKwqkLZ/ybE5o8BOxLi7W+AzcvK/Y7we1O63A9gZvcBC4GjcbVT73y6vqy/EL5IBryrQrmDgT5gesm6VxA6TW/N7n+J8OWdWFJmNvAsJXmjgVuBC0ruPwrcWLa/i4A/JO57ddm+PwcsKLn/OPDBsv2cDMwvuW/A10vudwArWZcnfHpWJjqnO3B4+OhHlb0VeAhC6uds3eeBRWWv1xVlj3sY+Pww9c4E1gBt2f1rgUuGKHsgsBwYU7b+HuC0en9mffGlWRbgUuBX2e1RhCFJT2ex7A7gTWXlxwGXZ9/Ppwmdz18Bl0bu73DghbL4ch3hH9nxg5SfVHJ72PZlsev7wDezfTxL6NCNAi4ElgwRg28ldJq/A7yYLecOxKqE1+ZWwlnGrwHPAc8A55XEPAGnAX8n/E7dNxDXE+q4lBD/S5fpw7zey4Fjhtg2KXv8W2M/I8OUOZPs99KX2ix+ZLZ4VLkIEI5kLjazRwdWmNlCYDEwo6Tc42a2tOT+08BDZtZdtm6LsvpvH+T+QL2x+36sbN+LB/YjaQowDfivbCjDcknLgbOB8rFjc0v200sIyuXtraY7LItQmduBrSVtUrJubtlj1j5XAEkHSroxG4LwEmHsbhfwsqzI94H3S7pX0nmS9iup6/XAWODZstfqNWz4Wjnn8vENwpmljxLOhtwH/LbsbMg3gf0IZ58OJJw9enPCPt4M3DUQX2LPzCW07wPAS8BehNj6beCXhH/Q9wAuAy4a5AxPpbNRMfseqKcXeCNwQlbH+7Nt/0E4Ano84Xfj64Tfg3cm1HESIR7/iHVHSJ9gZJZny6GSRo+wjgF/AfaUNGYj63GRvDNbPA8T/jvceSPqKO149QyybbB1eX0WKu17YD8Dfz8B7FqyvIZwKr5UNdublyHbKGlbwinCBwjDPF5P+BGA0KHFzH4DbEs46jAZ+LWkH2Vl2gj/cOxatuwEfCH/p+Jca5M0Dvgk8G9m9msze4AQq54mdL6QNJ7wPf43M7vRzOYROmf9JfVMy8Z0zs/GzL+3bFfbEv7xHbA94YDGAxvbvsw8M/uSmT0MnE84utljZt8xswWE8Z0C9i3bxVPAiWb2NzO7inBk9pTEfUM4y3ammT2U1XMLcFBWxynAsWb2WzN7xMx+Bvwwtg6A7GBJN7DSzP6RLX3DvXZDyQ6UHEMYHrBE0u3ZgYW9Bik+s/TAgqTflG1fDHQSht+5Gihah6DlmdkLwPXACVmwXE/JRUMPAC/PxlcNbHsF4cszP4em7D3I/YEAu9H7NrOnCV/4V5rZgvIloZ0DR5jbEx6Taq+yscB7E45ML4t8/B6ETuunzex2M3uIQYKcmT1nZj82s2MIP4ofljSKMH5uS6B/kNfqmY15Ys65Qb2S0Bn548CKrJNUeoZqoMxfSsqsIBs7mekFTjazGYTrBr6ddeQGjCGcph8Qe2Yupn2w/lktI5ymv69kXQ9hGEH5ma7hzkbF7nu9/WcGzljNAEYTjuaWnm36JMOcmSurI3dm9t+E2PzPhLGybwTukPTvZUVvY/0DC8eWbR8Ym+tHZmuko94NcIM6nhAo5kj6AuHLLMKFVmcA2xAGoM8FfirppOxx3yN0fG7OoQ17SzqDMMZ2f+BDhNM95LjvLwLfk7SEME6sk3AB1dZm9vXIOp4hBI63S3oUWF02tGGt7KKxzQjjbCm5+nTBYKf0Sryc8CP0n4SLtD5LOEUW62HCP44nS7qa0Bk+uaxtZxFev3mE7+W7gYVmtkbS7wifh/+RdBrwN8LwhJnA78zs9wltcc5tnOg5qs3sKcJRTszsH5KeI8SgFVmR54BNSx5SembumhzaV88zc0Ptv61kf/9MGLc73GNqembOzFYDN2bLWZIuAr4k6byS4XkrKxx02Sz7+2y12unW50dmCygbf7o74ct0DqHjeDNwKGHs0sB/2YcRviy3ZMs/gH8p+496pM4nXEV7N6HjdqaZzc5z32Z2EeE03QeBe4HfZ8/vkeEeV1ZHL3Ai4T/jxYRZD4ZyVvZ8zs3u350tlaa4+inhyO+fCafBLga+ldDGuYSxXacQjlwfC5RnDFtDmOnhXkLHdQIh0A+83u8gfAZ+CDwIXEWY9WAxzrm8/Z1w1mft6XdJ7YQxpPNLyvQQZoYZKDOWMFRqA5JeD7SbWemYzrspOZqZcGYupn0bY7izUXnsez4h5m07yNmmxxLb2k11z8zNJxxgSBlH+xrgyewMpKuFvK8o86XxF8LV+afWux1FWCib6cEXX3xp3oX1ZzP4NuGo6jsIR0pnES4Q2qqk/A+yeHkQoVP6M2Ap8KOyejcjnHV5Y9n61xJmhtm8ZN0rsv3+jTDG/lWE8fGfJFzQS0z7BotdhCEQXypb9w/ghJL7txIuGvtOtu/DCTMfnBq772H2X/r6/gfwPOGAxvaE0/WfAI6LrSO7Pwu4i3DGbTIlsy5k28ezbjjASsJMA7sC25SV25xwwOBowoGc7bLX/x+UzO5Tvv9hPkcX1/vz3EqLDzNwzjnnNvRv2d8fEaZtuhuYaWHowIBTCdNzXUvozH2LML597TjYbNz7L4GzzexPpTsws/sk/QU4gjBdFma2UNLuhGQK5xDml36ecNbmuMT2jVTp2Shjw7NReez7C4SLxk4lzOayjDDd4DcS23oeYVaG+YQxqtsR/sEYsAfh7OGAL2fLZYQLvgYsJ0wxdhKhcz2KMEXaz0gYVpbNhPAuwjzBrkaU/Rfh3FrZ2NMLzOy8erel3hQyit1vZifUuy3OuWLLOq6PAeea2TezU/U/Ax40sy8N8ZiZhKOgM2yEV+LnyWPexpF0PHCYmb2t3m1pJX5k1m3AzKbXuw1FYWb717sNzrlikrQb4TT7Xwjj3P8t+/vzrMi+hDlR50r6l2zdBy1kiQLAzH4r6UJgKqEj7BpbDyGrpqsh78w655xzI3cKYWxpL+E0+VvMbBGAmf2BiAutzey71Wygqx0zm1XvNrQiH2bgnHPOOecalk/N5ZxzzjnnGpZ3Zp1zzjnnXMPyzqxzzjnnnGtY3pl1zjnnnHMNyzuzzjnnnHOuYXln1jnnnHPONSzvzDrnnHPOuYblnVnnnHPOOdewvDPrnHPOOecalndmnXPOOedcw/LOrHPOOeeca1jemXXOtQRJl0h6RtL9Q2yXpO9KWiBprqTda91G55xrZtWKw96Zdc61ikuBmcNsPwTYIVuOA75fgzY551wruZQqxGHvzDrnWoKZ3Qa8MEyRw4DLLbgDmCRpq9q0zjnnml+14rB3Zp1zLtgaeKLk/qJsnXPOudoYURzuqFpzCqBLo22MxlWncimtfFtieSX8n9Ge9j+JdbYnle/rim9775ikqmkf3RtddnRHfNmRWN3bGV22b03aa9i+Oq0t7d0WXbatuz+t8t6+tPL9CeX749sNsMxeeM7Mpgy27e0HjLPnX4jb911z18wDSl/lWWY2K6kxriq6Osba6FGTossr7SOUpi/xu1LFzz6WWD71NydFyu9Tym8TpP8+dcSX7+9Mq7s/sceTUt5Se1Ptae+/2uLLK/FLtPrvTw0Zh6ExYnFTd2bHaBx7j35HdSpvT+vMaPSotPJj4nuFNnF8Ut3dW6R18JdOj2/7izOSqmaTVw13tmF9O23+TFLd/aQF/wef2yK67LKFk5Lq3uThtKA78dGe6LJjFq9IqrvtuaVJ5W3ZS/Flu7uT6r5h1U8eG2rbcy/08efrp0bV07nV31eb2R5JO9/Qk8C0kvtTs3VuI4weNYm9ZxwXXV69CR3OvrQf7bblK5PK20vL48uuXpNUN32J/1S2pRzgSPx96or/R16jRyfVbZuk/d70TI7/PVu1ZVdS3Su2SHtdVk+OL9u9Wdo/Sv0T42M8wKhx8bG1qyvtwM+8w74yZByGmsfiEcXhQgwzkDRT0oPZ1WunD7J9lKSfZ9v/LGl6HZrpnKspo8/6o5acXAt8KLuadm9gqZk9lVfljcBnfHDObaimsXhEcbjuR2YltQMXAgcTxkbcKelaM5tfUuxjwItmtr2kI4BzgPfXvrXOuVoxoJ/8zjlLugLYH5gsaRHwRaATwMx+AFwHvANYAKwEPpLbzhvHpcAFwOVDbC+90ngvwpXGe9WkZc65usgzFlcrDte9MwvsCSwws4UAkq4kXM1W2pk9DPhSdns2cIEkmaUOOnLONZJ+cjvqipkdWWG7AcfntsMGZGa3VTjztfZKY+AOSZMkbdVqR7CdazV5xeJqxeEidGYHu3Kt/D/9tWXMrFfSUmBz4LnyyiQdR5ibjNHVuvjLOVd1htHn/68WzVBXGq/XmV0vDndNrFnjnHP5a4RYXITObK6yq+ZmAUxs27zYr75zbkgG9OR4ZNbVTmkc3mTcyz0OO9fAGiEWF6EzG3Pl2kCZRZI6gInA87VpnnOuXvIcM+ty4TM+ONeCih6LizCbwZ3ADpK2k9QFHEG4mq3UtcCHs9uHAzf7eFnnmpsBfWZRi6uZlp/xwblW0wixuO5HZrMxsCcA1wPtwCVmNk/SWcAcM7sWuBj4saQFhDRoR9Svxc65Win2ia3m4zM+OOcGU/RYXPfOLICZXUcIkqXrziy5vRp4b63b5ZyrH8PoK/iprWbjMz4458o1QiwuRGfWOec2YMkJnpxzzuWtAWJxU3dmDbCUXNwp2StSx4Z0Jw5P7kh4a7rT0uK1rUlLo9jenZATuq96+cPbEvNN91taW/oSyivxnEtbYiRQSvmU9J+QnEYzZXh60vetUl0U/9SWq8w62ujePD49d8eK+FSc7ctTU8gW6BOVkp4WklLUqr2Kvzedad0G60or3zs2/nl2j0t7nj2bJBWnZ5P4z0tqetpxE1cnlZ84dlV02fGdaWnF51XY3gixuKk7s865Rib6qN4/R84552IUPxZ7Z9Y5V0gG9Bf81JZzzjW7RojF3pl1zhVW0Y8GOOdcKyh6LPbOrHOukAzosSJMhe2cc62rEWKxd2adc4VkFP9ogHPONbtGiMXemXXOFZIh+gqRpNA551pXI8Ri78w65wordXo155xz+St6LPbOrHOukBrh1JZzzjW7RojF3pl1zhWU6Cv4RQfOOdf8ih+LvTPrnCukkHWm2AHUOeeaXSPE4ibvzFpSilpLmBVYpKUETU0hSm98Skf1xJcFaOtJS0zXltL0xDMRHe3xbRnVlvY86U/7eLcnpMtNHj6UOOF0SuZeJaZWtv4qpr9NSQkds+scT21Jmgl8B2gHLjKzs8u2bwtcAkwBXgCONrNFuTWgRfV3ihUv64wu37U8Pp3p6I60z0dnd1oMUUIcTp5VPvW7ooTORFf86w2gzvjyNqorqe6+sWnle8clpLOdmPb+r5mUmBJ9cnyK2k03W55U99SJS9PKj10SXXZSx8qkun8XUabowwyK3dV2zrUss3BqK2apRFI7cCFwCDADOFLSjLJi5wGXm9kuwFnA13N+Ss4513DyjMXV4p1Z51xh9aOoJcKewAIzW2hm3cCVwGFlZWYAN2e3bxlku3POtaQcY3FVNPkwA+dcozJEt+UWorYGnii5vwjYq6zMvcC7CUMR3gVMkLS5mT2fVyOcc67R5ByLq8KPzDrnCmngooOYBZgsaU7JctwIdnkqsJ+ku4H9gCchdXC8c841l8RYXBfF7mo751paX/yVds+Z2R7DbH8SmFZyf2q2bi0zW0w4Mouk8cB7zGxJdGOdc65JJcTiuvDOrHOukHJOoXgnsIOk7Qid2COAo0oLSJoMvGBm/cAZhJkNnHOupTVCOttit84519L6rS1qqcTMeoETgOuBB4CrzGyepLMkHZoV2x94UNJDwJbAV6vzrJxzrrHkFYurxY/MOucKKaRQzC84mtl1wHVl684suT0bmJ3bDp1zrgnkHYurwTuzzrlCMlT4cVrOOdfsGiEWe2fWOVdYRU+h6JxzraDosdg7s865QjKjrhllnHPONUYsbu7OrIGl5MtOyJVt/YlvbEp+e0Ap5fsSc3xbYg7xlKrb0+ruao9/nuM61iTV3daX1pa2toTXMfWMSzXP0KS+n6k55PtTvhd5frbqm1HG5cPaoXuThPcx4UezfXXaT1j76K7E8qOiyyZ/UlO/t+3t8WXb0n6fbFRnQtm017x/VEK7gd5R8a9k75ikqukbn/ZbOWpcd3TZLcYvT6p7+ri0XCzTRr8QXXZKx0tJdVdW/Fjc3J1Z51zDMop/NMA555pdI8TimrZO0kxJD0paIOn0QbZvK+kmSXMl3Sppasm2cyTdny3vr2W7nXO1Z4gea49aXDxJl0h6RtL9w5TZX9I9kuZJ+r9s3WhJf5F0b7b+y7VrtXOuXhohFtesMyupHbgQOASYARwpaUZZsfOAy81sF+As4OvZY98J7A7sSsinfqqkTWrUdOdcnfTRFrW4JJcCM4faKGkS8J/AoWb2auC92aY1wIFm9jpCLJ4pae+qttQ5VwhFj8W13POewAIzW2hm3cCVwGFlZWYAN2e3bynZPgO4zcx6zWwFMJdhgrFzrvEZxZ+ouxGZ2W3AcAPwjgKuNrPHs/LPZH/NzAYGBnZmS/UG4DvnCqERYnEt97w18ETJ/UXZulL3kuVGB94FTJC0ebZ+pqSxWcrJA1g/z/pako6TNEfSnB7SLhhyzhWJ6ItcXK52BDbNhnrdJelDAxsktUu6B3gGuNHM/jxYBaVxuHfVitq02jlXJcWPxUW7AOxU4AJJxwC3EXKo95nZDZLeAPwJeBa4HRj0MngzmwXMAthEm/lRA+ca1MDRAFdzHcDrgYOAMcDtku4ws4fMrA/YNRuKcI2k15jZBmNvS+Pw2C2neRx2roE1QiyuZWf2SdY/mjo1W7eWmS0mOzIraTzwHjNbkm37KlmudEk/Ax6qfpOdc/XkR13rYhHwfDaka4Wk24DXURJzzWyJpFsIw72GvJDMOdccih6La9nVvhPYQdJ2krqAI4BrSwtImixpoE1nAJdk69uz4QZI2gXYBbihZi13ztWcmQo/TquWJI3K4ucMSVOquKv/Ad4kqUPSWMJFtw9ImpIdkUXSGOBg4G9VbIdzrgAaIRbX7MismfVKOgG4HmgHLjGzeZLOAuaY2bXA/sDXJRlhmMHx2cM7gd9LAlgGHG1mvbVqu3OuPoo+t2G1SZoAHA0cSbiItpMwP79JepIQT2eZ2Z0JdV5BiLWTJS0CvpjVi5n9wMwekPRbwoW2/cBFZnZ/diDhsmxmmjbgKjP7VU5P1TlXYEWPxTUdM2tm1wHXla07s+T2bGD2II9bTZjRwDnXIgwKn3WmmiSdAnwOWEg4i/VVYDGwCtgMeA3wZuBGSXcAnzKzhyvVa2ZHRpQ5Fzi3bN1cYLfEp+Gca3CNEIuLdgGYc85lVPijAVW2N7DfYBdYZf4CXCLpE8DHgP2Aip1Z55xLk28sljQT+A7hLP1FZnZ22fZtgMuASVmZ07ODoUNq/s6sJeRiTsqVnZbjOVmuOe43Tn9CUo/+UWntHt8VP33aJh2rk+pO1dme8J5W+5/UlPc/Ncd7IkupP+X7VqkqaOnsXmb2vshyawhJDgrJ2qB3bHz5tu74sn2j0n5grTOxfHt8ebVX+bOa0BbrTPxp7+qMr3tUfFmAvtFpr0vP2Pjg2jM+MfZt0pNUfMuJL0WX3X7Cc0l1zxi7OKn89K74+jdrX165UII8Y3FJAq2DCReb3inpWjObX1Ls84RhTN/PkmtdB0wfrt7ob4ekLSWdKun72VyvSNpX0naJz8U55yoyRL/FLc1K0i4lF8U651zN5RyLYxJoGTCQ5XUiYXjVsKKCpKTXAw8CHyCczhrYycFk02U551ze+mmLWprY3cDkgTuSfi1pqzq2xznXghJi8eSBhCnZclxZVTEJtL4EHJ1doHod8KlK7Yv9FTgP+I6Z7QbrpdW6Htg3sg7nnItmBn2mqCWGpJmSHpS0QNLpg2zfRtItku6WNFfSO3J/UunKn9xbCIkMnHOuJhJj8XNmtkfJMmsEuzwSuNTMpgLvAH5c6QxV7MCa1xOOyJZ7CtgyqYnOORcpryEE1Rqn5ZxzrSDH4VwVE2gR+pszAczsdkmjCWeonhmq0tgjs6uATQdZv9NwlTvn3EiFcVq5TdRdlXFaNWDZUr7OOedqIudYXDGBFvA4IZ02knYGRgPPDldp7JHZ/wG+KOm9A89N0nTgHOC/I+twzrkkOaZQHGyc1l5lZb4E3CDpU8A44K157XwjCPiJpIHhXaOBH0paWVrIzA6tecuccy0jr1gcmUDrM4Q492nCP+/HWIVpdWI7s6cSTrk9C4wF/kAYXvBHwqk555zLlZF0amuypDkl92eNYKzWwDitb0rahzBO6zVmOc43lu6ysvs/qUsrnHMtKzEWV66vcgKt+SRejxXVmTWzZYRc3QcCuxOGJ/zVzH6XsjPnnIunlFzfz5nZHsNsr8o4rWozs4/Ua9/OORckxeK6SJpZ2cxuBm4GkJQ2c7JzziXKMYXi2nFahE7sEcBRZWUGxmldGjtOq14kdQCjzSzf2dGdc24QRU9nGzvP7ImS3lNy/2JgVTbNzauq1jrnXMsyg57+9qilcl3WCwyM03qAMGvBPElnSRoYb/oZ4OOS7gWuIGKcVrVJOkjS+8rWnQ4sB5ZI+q2kSXVpnHOuJeQZi6sl9sjsicBHASS9BXgf4ajGe4BvAv9Uldblob6/RSPXlvBfUEpZoL8z7QPXOya+fhufli5w67FLo8tO7Xohqe6nNTGp/JjO+LZbR9rnyhLfo9T3NEk1h4Dm+H0byDqTW31VGKdVA6cDvxm4I2lP4GvAxYRO+WeBz2V/C8naoGdcfPm2nvj3vPeltM+HJcY+UlLUdlT5h7wt4TRvYmrdlNelb1RietpxaaenuyfFv6fdm/cm1T15s7QTGTtMjD8xs8v4JyoXKi0/Kq381I5V0WU3a+tKqruSvGNxNcR2ZrcGHslu/zPwCzO7StJ9wO+r0jLnXMsr+qmtGngtoUM74L3An8zs4wCSngD+gwJ3Zp1zja/osTj2X6ZlwBbZ7YOBm7LbPYRxZc45l6uBK2hzygfeqCax/gVo+wK/Lbl/JxumgnTOudw0QiyOPTJ7A2HOr78C27PutNerWXfE1jnnclX0K2hr4CnglcATkkYBuwFfKNk+gfVTjDvnXO6KHotjW3c8YU7ZKcDhZjYweHF3woUSzjmXr8gjAU1+ZPY3wDeyaRHPAVaw/tCuXYAF9WiYc65FNEAsTpln9lODrP9i7i1yzjmyU1sFH6dVA2cCVwO/I8xg8OEsHe+AjwI31qNhzrnW0AixOGmeWQBJLwPWu1TOzB7PrUXOOZdp8qOuFZnZc8BbJE0ElptZX1mR9xI6uc45VzVFj8VRndkskH6XMCXXYHM+1G9yMedcU8o7hWIjM7NB57ArGfLlnHNV0QixOHbM7HnA64B/AVYT5pj9LLAIeH9VWuaca3lFH6flnHOtoOixOHaYwSHAkWb2e0l9wF1m9nNJTwH/CsyuWgudcy3JEL0Fv4LWOeeaXSPE4tjWTQIey24vBTbPbt8OvDHnNjnnHFjxjwbUgqRJkt4p6Y2SVLZtnKQzh3qsc85ttAaIxbGd2b8Dr8huPwAckQXVdwM+Zss5l7tGmKi72iS9mhBz/wf4A3CnpG1LiowHfFYZ51zVNEIsjh1mcClhPsNbgbOBXwEnEDrDJ1WjYblRwoubkldeaYfcldIOSMqtbZ1pk1L0jU0rv2az+LZP2HRlUt2vHBuf+3pa1/NJdaea0BU/97x19ifV3Z+Yt71h+2epn/MKX7lm7qhG+jrhDNgHgU2A7wB/lHSAmT1c15ZFMkHf6PjY2js6/j3vG5X2+egblfY97GhPiPOpn/1E1pZQf0q7AeuIL2+daXX3daW9Lr0pOUXHlE/uMbxNRq9OKr9Z14rospu3p00qMrEtLdfJpLb43+2xbYNdp79xih6LY+eZ/VbJ7Zsl7QTsATxsZvdVq3HOudZlNPdR10h7AweY2QpCwoT3STofuFXSAYRhX845VzWNEItHNKLXzB43s6tTOrKSLpH0jKT7h9i+qaRrJM2V9BdJrynZ9mlJ8yTdL+kKSSn/uznnGpSZopYmNoqy49dmdgpwFeFM2c6pFUqaJukWSfOzuLrB2TVJH8hi8X2S/iTpdSXbJkmaLelvkh6QtE/ys3LONZSix+Lo49aS9gIOAragrBNsZidGVHEpcAFw+RDb/x24x8zelR35vRA4SNLWwInADDNbJekq4IisPudcEyt61pkaeJBwFmx+6Uoz+7SkNsJY2lS9wGfM7K+SJgB3SbrRzEr38Qiwn5m9KOkQYBawV7btO8BvzexwSV3A2BG0wTnXQIoei2OTJpwKfIOQA3wx6x8piBoMZWa3SZo+TJEZhPG4mNnfJE2XtGVJO8dI6iEEzsUx+3TONS6z4o/TqoFrgCMZ5CCAmZ0kqQP4ZEqFZvYU8FR2+yVJDwBbU9JhNrM/lTzkDmAqrE2g8xbgmKxcN1CaXtc512QaIRbHDjM4CTjRzHY0s/3N7ICS5cCc2nIvYXYEJO0JbAtMNbMnCUkbHicE4KVmdsNQlUg6TtIcSXN6SBtg7ZwrlqKf2qo2M/u6mR0yzPbjzUY+AWR2gGE34M/DFPsY8Jvs9nbAs8CPJN0t6SJJ4wapd20c7l8RfxGNc66Yih6LY4PgJsB11WwI4ajsJEn3AJ8C7gb6JG0KHEYIoi8Hxkk6eqhKzGyWme1hZnt0MqrKTXbOVU/cVDBFP2JQVJLGA/8NnGxmy4YocwChM/tv2aoOYHfg+2a2G+GitNPLH1cah9vGbdDXdc41lOLH4tjO7BXAzGo2xMyWmdlHzGxX4EPAFGAh8FbgETN71sx6gKvxRA3ONT0D+vrbopYYkmZKelDSAkkbdMAkfUvSPdnykKQlOT+lwpDUSejI/tTMrh6izC7ARcBhZjYwL94iYJGZDRzJnU3o3DrnmlTesbgahhwzK+mUkrtPAF+WtC8wF+gpLWtm529sQyRNAlZmY7COBW4zs2WSHgf2ljQWWEW4CG3Oxu7POVdwljb183AktRMuKj2Y0CG7U9K1pRc9mdmnS8p/inD6vRAkbQM8Ybb+K5Ilr5lmZo8n1CXgYuCBoWJ3tr+rgQ+a2UMD683sH5KekPQqM3uQEI/nD1aHc65J5BiLq2W4C8A+VXZ/OeGIaPlRUQMqdmYlXQHsD0yWtIiQtaYTwMx+QJhi5jJJBswjnNrCzP4saTbwV8JVuHcTrqx1zjW5HK+g3RNYYGYLASRdSRi+NFRH7EiKlVnrEWAr4Jmy9Ztl21KyAexLSMJwXzasC8JsMtvA2nh8JiFt+X9mCV96zWyPrOyngJ9mMxksBD6S+mScc42lYWczMLPt8tyRmR1ZYfvtwI5DbPsixfphcc5VmUGeFxRsTTjDNGAR66aaWk+WLnY74Oa8dp4DMfjMMeOBpLRGZvaHrL7hyhxLOEM22LZ7CNOFOedaQM6xuCrS8pqy9qIBzCwtd5tzziVJuqBgsqTS4UezzGykZ3COAGabWVquzCqQ9N3spgFfl1SaL7qdcMT5nlq3yznXSop/oW1K0oSTgVMIRziQtJgwvODb5eO4CkUpubUTiran5fimszOpuLricyv3j02btaF7Ytr/MKs3i397d5iYll1z+9H/iC67dXta3as70vJTb9KZcICrqz+p7v60tx9rT/gwtiUOuk/5TgBKyDlviXVXrC/+o/dcyWnwwTwJTCu5PzVbN5gjgOOj91xdr83+ijAUq3RO127C8Kvzat2oJALriH8j+7viP299iSno+zvTfpCtI/7znPI9CZWn/WyqP7588k9yWjhLosSmtKX8C9mdFm9WdKd9YF7ojp+J44muzZLqHteWNnVoT0Lm6gnK/1hjgXt5QHzShG8AxwHnArdnq/chjKvaCjitKq1zzrW0HE9t3QnsIGk7Qif2COCo8kJZ9sFNWRfn6srMDgCQ9CPgpKGm0HLOuWpqlmEGxwLHmtnsknU3S3oQ+C+8M+ucy5lZfgHUzHolnQBcTzg9f4mZzZN0FjDHzK7Nih4BXFm0s01m5hdZOefqIs9YXC0p55vnDrGufhOLOeeaWp7jtMzsOsqSv5jZmWX3v5TbDnMm6f2EqbC2oCzumtmhdWmUc64lFH3MbGxH9HIGH0P2SeDH+TXHOefWMYtbmp2kc4GfANOBJcDzZYtzzlVN0WNx7JHZUcBRkt4O3JGt24uQXvanJVfcYmYn5ttE51wrMkR/HTPKFMyHgCPLhno551zVNUIsju3M7kS4ahZg2+zvP7Jl55JyLXCMxDlXKx5Q1mrDp+ByztVJ0WNxVGd24Ipa55yrmQa46KCGZgFHA1+qczucc62mAWJxctIE55yrmaIfDqidSYShXgcTLrztKd3ow7ucc1VV8FjsnVnnXGEV/WhADc1g3TCDncq2FfxnxjnX6Ioei70z65wrrFaYqSCGD/VyztVT0WNxc3dmJdRZnaeYms5WXYn5TEfFp93rG5eWznb1xLSrEns3640u+4rxabMETe98Lrrslu09lQuVWJaYLCklnW37qJSci9BfxbSbKSk3Ado60j67lpCKWakRb5iX0Sj+0QBXmQzauuPfx7aEr7kS07CmplZNSvOanEI2sfEpaav70upWX3w8U09a3e3daa9Lx8qEupel/b4/t2R8UvmHO6ZEl02dh3Vp79ik8lt2xqezndSe8CIC4Vr+oTVCLC72XAvOudZlgCluaQGSDpH0a0kPSJqWrTtW0kH1bptzrok1QCzeqM6spDZJ2+TVGOecK1X0ibprRdIHgKuAhwiJEwYOl7fj6cSdc1VW9Fg8bGdW0mhJP5D0rKSHJJ1UVmQK8Ej1mueca2kWuTS/04CPm9mngdJxP3cAu9alRc651pFjLJY0U9KDkhZIOn2IMu+TNF/SPEk/q1RnpQEnZwL/lP2dCHxe0huAD5nZwMCZ1jjH55yrMWH9Hl4yOwC3D7J+ObBJjdvinGsp+cViSe3AhcDBwCLgTknXmtn8kjI7AGcA+5rZi5K2qFRvpWEG7yccDfi+mZ0N7AHsDvxM0sBjW+O4iHOutrKJumOWFrAY2HGQ9W8B/l7jtjjnWkm+sXhPYIGZLTSzbuBK4LCyMh8HLjSzFwHM7JlKlVbqzG4FPLD2+Zg9BhwAvDZrQOIl+s45l8CHGQyYBXxX0r7Z/WmSPgx8A/h+/ZrlnGsJ8bF4sqQ5JctxZTVtDTxRcn9Rtq7UjsCOkv4o6Q5JMys1r9Iwg6eA7YFH1z4fs6ezq2dvAS6vtAPnnBu5ljjqWpGZfUPSROBGYDQh/q4BzjOzC+vaOOdcC4iOxc+Z2R4bubMOwtCq/YGpwG2SXmtmS4Z6QKUjs7cAR5WvNLN/AAdmO3HOuerwI7NrmdnngMmE03R7A1PM7Av1bZVzriXkF4ufBKaV3J+arSu1CLjWzHrM7BHCLC47DFdppSOzX2HD1IkAmNlTkvYD3lahDuecG5kW6ajGkPR+4CBgC7IDEVI4WmJmh9avZc65ppdfLL4T2EHSdoRO7BFseND0l8CRwI8kTSYMO1g4XKXDdmazMbKPDbP9KeCySi13zrlkAxN1OySdC5xMOFu2GO/mO+dqJcdYbGa9kk4ArifMk32Jmc2TdBYwx8yuzba9TdJ8Qp7Iz5rZsOlFmzudrXOuoeU5CXd2EcF3CAH0omyGlvIy7wO+RAjf95rZBsOs6uRDwJFmNrveDXHOtZ48Y7GZXQdcV7buzJLbBpySLVGaujMrCXV1xT8gIVe2OtNeOiXktwewUfHt7hub1pbuTdL+w+rcZE102WmjX0iq+2Xt8XVPbh+TVPcL/auSyk9KSAre2RmfyxygP3Hej/7O+PfIuhK/xgmfLQB1d6fVn2J1he05BdBqzW1YQ23APfVuxIj0Q8fy+M9zR8LXNiF8ANDWEx/jAdSX8D1P+P0AoDcthtAW/2VIPobWHp8MtK07rd3tq9Jel87l8W3pWpb2TFeNS4t9T7XHT+Hc25+WUHVpz+ik8otHTYwuOz71i8GdlYsU/FzQRqWzdc65qsovH3hV5jasoVnA0fVuhHOuReUXi6uiZkdmJU0jTOW1JaGPP8vMvlNWZlPgEuCVhGM2HzWz+7NtnwaOzR57H/ARM6t0XMc516gMFH9QZ7KkOSX3Z5nZrJL7g81tuFdZHTsCSPojYSjCl8zst0ltrp5JwFGSDgbmAj2lG83sxNiKImPxROAnwDaE34nzzOxH2bZzgHdmRb9iZj8fyRNyzjWItFhcF1GdWUk3A+8un+NL0ibAL83swIhqeoHPmNlfJU0A7pJ0Y+lpPuDfgXvM7F2SdiKcFjxI0tbAicAMM1sl6SrCFXCXxrTfOdeIkv7Tr8vchjU0g3XDDMpnmEk9ARgTi48H5pvZP0uaAjwo6aeEYRq7A7sCo4BbJf3GzJYltsE51zDqe9Q1RuyR2f2BwQabjAbeHFNBNvPBU9ntlyQ9QDhaUhpAZwBnZ2X+Jmm6pC1L2jpGUg8wlnBFr3OumeU3Tit2bsM/m1kP8IikgbkNIwaUVZeZHZBjXTGx2IAJCnN/jQdeIHSCZwC3mVkv0CtpLjATuCqv9jnnCqiRx8xK2l3S7tndXQbuZ8sbgOPY8AehIknTgd2AP5dtuhd4d1ZmT2BbYKqZPQmcBzxOCMJLzeyGIeo+biCNWrePQnCuseU3UffauQ0ldRHO7FxbVuaXhH/ciZ3bsNENE4svAHYmHDS4DzjJzPoJMXqmpLHZa3QA6/+TMFDv2jjct2JFNZ+Cc64WCp7AptKR2Tmsa+JgncdVwKdSdihpPPDfwMmDnJo6G/iOpHsIAfRuoC8bS3sYsB2wBPiFpKPN7Cfl9Wfj5GYBTGyfXPD/JZxzw8rpG1ytuQ1rKTtLdTzh6KgRjqT+p5k9PcL6hovFbycMaziQcA3DjZJ+b2Y3ZAcy/gQ8C9xOeK3WUxqHR798msdh5xpdwb/FlTqz2xFm+VhIuBr42ZJt3cAzZhY9T4ekTkLw/KmZXV2+PQuoH8nKCngk2/fbgUfM7Nls29XAGwkXKDjnmlHOSROqMbdhrUjaF/gt8DShAwnwAeDTkt5uZrcP+eDB6xs2FhPi8NnZa7JA0iOEsbp/MbOvAl/N6vkZIdWkc65ZNUACm5gMYJDDFF5Z5/Ri4AEzO3+IMpOAldnUOccSxmYtk/Q4sLeksYSjwQcRjho755qYCn40oIbOA64APpGd7kdSG/AD4JuEf+6jxMRiwpCug4DfZ0eEXwUszObrnWRmz0vaBdiFwc/aOeeaSNFjcfTUXJKmAm+hJC/4gGECYql9gQ8C92XDCCDMXrBNVscPCGO0LpNkwDzgY9m2P0uaDfyVcBHC3WSnsJxzTazgAbSGdgWOGejIAphZv6TzCfEwRUws/gpwqaT7CGfn/s3MnpM0mtDBBVgGHJ1dDOaca2YFj8WxU3N9gDD/ay9hqEHp0zKgYmfWzP5AhcQk2amyHYfY9kXgizHtdc65JrOUMOzrwbL1A9cRRIuMxYuBtw2yfjVhzK5zzhVG7JHZswinsr6QMka27iTUkZAXwhJmBU6pFyA5nW18/b1j2pPq7h2XVJwxo3sqF8qMb0+bQWK04sfhdCrteY5W2kd1VFv8Aab29rQZpPvSmk5/R/zr0t+ZNgqorZqpmPvz/fe96Ke2auhK4GJJpxEuvoJwhPUcwvCDwlIfdC6PL9+5Mv5N71id9j1s665iytnU9LQpqXIhPV1uioS2p6az7VidVr5zRXyw7HwpbRxn79i0QNzdMSq67LOVi6xfd+KPwtLR8encx3TE/2bHKnosjv1V2xK4qKE6ss65xlfwiw5q6DTC0dRLWBe3e4DvA6fXq1HOuRZR8Fgc25m9jpD6sannXHTOFYgBBU+hWCvZRbEnSTqDMFUWwN/NbGUdm+WcawUNEItjO7M3AudIejVh/tfyvOCDTe3inHMbpeintmrNzFZm02ThHVnnXK0UPRbHdmb/K/v774NsM8Ik5M45l6+CB9BaknQyYQ7crbP7iwkX3347mw/WOeeqo+ARJqoza2YbPc+sc84lK3gArRVJ3yCkDz+XdUkT9gHOBLYijKl1zrnqKHgsTrwk3znnakNW/FNbNXQscKyZzS5Zd7OkBwlnzrwz65yrikaIxVFHXBX8P0nzJK2U9Ips/emS3lfdJjrnWpYpbmkNc4dY52fOnHPVVfBYHBsETwI+T8i6VdraJ4ET8m6Uc84BWU7wiKX5XQ4cP8j6TwI/rnFbnHOtpuCxOHaYwSeAj5vZryX9R8n6vwKvzr9ZzjlX/FNbNTQKOErS24E7snV7AS8HfirpuwMFzezEOrTPOdfEih6LYzuz2wL3D7K+B4hPS+GccykKHkBraCfCwQMI8RjgH9myc0k5f8Wcc/kreGSJ7cwuBHYHHitb/w5gfq4tcs45gAa46KBWzOyAerfBOdeiGiAWx3ZmzwMukDSWMGZ2H0kfJFxB+9FqNW6jCWhPuDYiYfCyOhInguhIm4rXuuLr7xudNui6b3Tap3JsR/WyGHcnTI/Zk5hNubuBZ5RLabqlfMYh+bNIe0L51LZUUvCsM64y9UPn8vjvecfq+LKdK9M+IG1repPKqzch5vSlxSfrq96HO/UyHPUkfG+7017DttVpr0vKe9q5PO2Z9o5NK9/fGR/7utu6kupektg5XN0T3ycY3Zn2HkUpeCyOnWf2R5I6gK8BYwkXHCwGTjSzn1exfc65Flb0owG1JGlLYF9gC8ou3jWz/6xLo5xzLaHosTi6q29mPwR+KGky0GZmz1SvWc455wZIOhq4iHDQ7UXWH8FmgHdmnXMtK/mcoJk95x1Z51xN5DgdjKSZkh6UtEDS6YNsP0bSs5LuyZZjc3oWefgq8A1gnJm9zMy2KlleXu/GOeeaXDNMzSVpM0IwPYjBT3Ftkn/TnHMtLceLDiS1AxcCBwOLgDslXWtm5Rew/tzMijh39ibApWZWhcFwzjk3jCa6AOxiYDdC0oTFFH6SBudcU8gv0uwJLDCzhQCSrgQOo3FmY/kp8E7ge/VuiHOuBRW81xfbmT0IONjM/lzNxjjn3HriA+hkSXNK7s8ys1kl97cGnii5v4iQdKDceyS9BXgI+LSZPTFImXo4BfilpIOA+whzfK9lZmfVpVXOudbQJJ3ZZ4Dl1WyIc86VEkmntp4zsz02cpf/C1xhZmsk/StwGXDgRtaZl38FZgLPAduz4QVg3pl1zlVFYiyui9jO7OeAsyR92My8U+ucq438AuiTwLSS+1Ozdet2ZfZ8yd2LCBdcFcUXgM+Y2bfq3RDnXAtqks7s54HpwDOSHmPDU1y75Nwu51yry/eigzuBHSRtR+jEHgEcVVpA0lZm9lR291Dggdz2vvHagWvr3QjnXAtqogvAZle1Fc45N5icss6YWa+kE4DrCR3DS8xsnqSzgDlmdi1woqRDgV7gBeCYfPaeix8BH8CHEzjn6qFJMoB9udoNcc65cnkeDTCz64DrytadWXL7DOCM/PaYq7HAsZLeDsxlw7NjJ9alVc65ltAsR2YBkHQgMIMwemKemd1ajUblR2l55VMk1mudSS81/V3x9feOSsw3nZZCOsnKxMqX9sc/z9FandYW60wqv6Y//j3q70/Nfp7GEqq39sS2tCXmSulI+Kz35vx9K3gAraGdgbuz2zuVbSv0q6R+6FwZ38SONfFl21elHS7S6sRpenv7ootaX+Khq/74ulOlzkastoQHdPdULlOibXVaHG5fFR+HO1emxbLe5am/lfH1W0fab3zaqwj9ffGxtbuzCtNRFzrKxCdN2Bq4Bng9YZ5ZgJdnU+G8y8wWD/lg55wbiTpnlCkSMzug3m1wzrWoBojFsf92fBfoA7Y3s2lmNg3YIVv33ZgKJI2W9BdJ90qaJ2mDoQuStpV0k6S5km6VNDVbf0BJisl7JK2W9C+RbXfONShZ3NIKJG0p6SxJsyX9QtKXJG0xgnpiYvGgqX2zGP3XbN08SZ/I47k554qt6LE49rj4wcD+ZvbIwAozWyjpROCmyDrWAAea2XJJncAfJP3GzO4oKXMecLmZXZYNafg68EEzuwXYFdam1l0A3BC5X+dco2qRjmolkvYFfgs8DdyerT4aOEXS283s9iEfvKGYWAyDp/Z9Ctgnm4t3PHB/lhbYz84518wKHotTBnkM9lSin56ZGesSL3RmS/njZxAy3QDcAvxykKoOB35jZitj9+2ca0ytctQ1wnnAFcAnzKwfQFIb8APgm8AbYyuKjMVDPba75O4o4s/uOecaWNFjcWwgugn4nqS1k45L2gb4NvFHZpHULukeQkaxGwdJj3sv8O7s9ruACZI2LytzBCGoD7WP4yTNkTSnu39VbNOcc0VkkUvz2xX45kBHFiC7fT6wW2plEbEYQmrfudmwhtLYP03SXEJ64HMGOypbGod7V69IbZ5zrmhyjMWSZkp6UNICSacPU+49kkxSxeyOsZ3ZE4FxwEJJj2WJE/6erYueEsbM+sxsV0L2nT0lvaasyKnAfpLuBvYjTG6+9pJPSVsBryXMFTnUPmaZ2R5mtkdX25jYpjnniiY2eLZGZ3YpsN0g67cDlqRWFhGL/xeYniXEuZGQ2nfgsU9k67cHPixpy0HqXxuHO0aPS22ec65IcozFktqBC4FDCGfjj5Q0Y5ByE4CTgMH+0d5AVGfWzJ4AdgfeQTjddR5wiJntbmaLYuooq28JYRjBzLL1i83s3Wa2GyGF7kDZAe8DrjGz1FktnHMNRglLC7gSuFjSByRtly1HE9LuDnmmqpJhYvHzZrYmu3sRYSab8scuBu4H3jzS/Tvnii/nWLwnsMDMFmbDlq4EDhuk3FeAc4CoOTmjx8xm46xuzJZkkqYAPWa2RNIYwkVl55SVmQy8kJ0+OwO4pKyaIynupObOuZyp4Flnaug0wm/FJayL2z3A94EhT9MNJjIWD5raN5th5nkzWyVpU+BNwLdG9pScc40ix1i8NWGI0oBFwF7r7UvaHZhmZr+W9NmYSqM7s9lUWKcQDgtDCG7nm9k1kVVsBVyWHWJuA64ys1+VpZPcH/i6JANuA44v2f90YBrwf7Ftds41uNYYQlBRdgTjJElnAK/MVv99hBfCxsTioVL77gx8M4vRAs4zs/tG/MScc40hPhZPznIQDJhlZrNiH5xd2Ho+ienEY5MmfAb4GnA5cGm2eh/gZ5K+YGbnVarDzOYyyIUKZekkZwOzh3j8o4QevXOuVXhndj1Z53WjOo+RsXjQ1L5mdiOwy8bs3znXgOJj8XNmNtwFW08SDkwOmJqtGzABeA1wqySAlwHXSjrUzEo7yeuJPTJ7KnCCmf2wZN0lkv4CnEUYQ1s8guzFiBJGUsTWnThSL7G8tSWUT21KYhbF1T3xM7g91zMhqe5n++IvDhmtZUl1v9Q/Oql8Sirevr60GYnaUjtlKe9p4vufmv42qSmp34vhtFBChKFIOoQwlGAXM1tWtm0iYQaYj2edzEJSv9GZkHa2fXVKOtu0tJ1KTMVKT0L53sQUon3VS2dLe9oXJ6W0EtNht3WlveYdq+LT33auTEuf3bMiLT71dcWX7+9Iq7s3aWZU6OuLr78vIQ1vlHxj8Z3ADpK2I3RijwCOWrsrs6XA5IH7km4FTh2uIwvxsxmMJ1wkUO6WbJtzzuXPZzM4ATi3vCMLa4P+OcDJtW6Uc67F5BSLzayXENeuJwxXvcrM5mXZDQ8dafNi/zX4JSFZwdll698DXDvSnTvn3HBa/cgs4ZT+KcNsv5ls5hfnnKuWPGOxmV0HXFe27swhyu4fU2dsZ3YBcLqkA1iXSnHvbDlf0tpga2bnR9bpnHPD887sFGC4c/QGlCeWcc65fBU8Fsd2Zo8BXgR2zJYBLwIfKblvhKvQnHNuo/mRWRYRjs4+PMT2XVj/4gnnnMtd0WNxVGfWzAbLPOOcc9XT/ONhY/wa+Iqk68xsvfzcksYSLsD9dV1a5pxrDQ0Qi9Mup3POuVoqeACtga8Srld4SNIFwN+y9TsTLqIQYdpE55yrnoLH4pSkCe8CDgC2oGwWBDN7X87tcs61OJFvBjBJM4HvAO3ARWZWfkHrQLn3EOa7fkOl6WCqzcyekfRGwvRcX2PdTGlGuBr4eDN7ul7tc841v7xjcTXEJk34JvAp4I/A00AVJ8hzzrlAKXM/D1dPyHZ1ISF16yLgTknXmtn8snITgJOAP+ey4xyY2WPAO7L0sdsTflseNrMX69sy51yryCsWV0vskdkPA+81s/+pZmOcc26tfMdp7QksMLOFAJKuBA4D5peV+wph7taofODVJGk7M3tk4H7Web1ziLICpprZE4Ntd865EWuAMbOxSRNWsm6slnPO1YQsbiHLB16yHFdW1dZAaUdvEWXpsSXtDkwzs6JcUHW7pIsl7TNUAUmbSvokoVN+WO2a5pxrJQmxuC5ij8yeDZwm6V+z7A3OOVd9+eUDH5akNsK0gseMtI4q2ImQEOHXkvqBu4DFwGpgU2AG4UKwvwAnm9n19Wqoc67JFfzIbGxn9ofAPwNPSnoIWC/ZspkdmHfDcmFgKeM8+hPKpo4fSSyvvvjybYnpxttXpuWQXrl8VHTZJ1ZumlT342M2iy7bqbT/o57vS8u0/FLP6OiyvT1pOcFHJ75HShmVnhpkqjiQP+n7FiHH//SfBKaV3J/K+vOzTgBeA9waztjzMuBaSYfW6yIwM1sCfFbSmcA7gTcB2wJjgOeAy4Drzez+erQvlvqgY3n8B7p9TfwHtH1V2hdL3WnlrSe+vPUmHufpS7z0RAlxO/X3JqVwT+wJ3azu1d1J5dtWd0aX7ViZNiFT1+i0tvfHNwXrSPtdTdXbH/+b09+Xf1uaYp5Z4AeEQPpbwgVgBX9azrmmkF+kuRPYQdJ2hE7sEcBRa3djthSYPHBf0q3AqfWezQAgm192drY451ztFbzXF9uZfT/wLjO7sZqNcc65tXIcg2VmvZJOIExn1Q5cYmbzJJ0FzDGza/PZk3PONZk6j4eNEduZfRZPmeicq7UcA6iZXQdcV7buzCHK7p/fnvMlaQywmZk9Wbb+1WY2r07Ncs41s4J3ZmMHkHwROEtS2iBE55wbIVH8K2hrTdLhwMOEi8LmStqrZPOP69Qs51wTa4RYHHtk9rPAdOBpSY+z4QVgu+TcLuecQykXZbaGzwOvN7OnJb0euEzS18zsZyRex+Occ7GKHotjO7N+4YFzrrYaYKLuOugcSF9rZndJegtwjaTt8VfLOVcNDRCLozqzZvblajfEOefKFT0feB08I2kXM5sLYGYvSDqYME2XnyFzzlVF0WNx0iRtkg4kTNRtwDwzu7UajXLOOaDwRwPq4IPAehOamlk3cKSkC+rTJOdc0yt4LI7qzEraGrgGeD0hAw3AyyXNIUzZtXjIBzvn3Ai10sVdMcxs0TDb/ljLtjjnWkfRY3HskdnvAn3A9mb2CICkVwA/ybYdXp3mOedalpGeaa9JSbpkiE1GSG+7APi5H1hwzuWuAWJxbGf2YGD/gY4sgJktlHQicFNVWuaca3lFPxpQQ1OANxOSEQ+kr30NYQaDu4B3E6ZPfLOZ3VOXFjrnmlbRY3HKmNnBnkrBn56l5b9O+c+jLzE/dW9aHu62nvjyHavTRmZ3vZTW9tVLu6LLLlo+KanuR8ZvEV22S2mv4bO9mySVf37NuOiy/avj82QDtKWlhKct4amqLzEPe3/iSP6+hPKp+eYrKXiEqaE/AsuBj5nZSgBJY4EfAvcC7wAuB74JHFSvRg5GZnSsiv9ctK3prVxooO41iV+sNd1p5Xvi20JPWlusike61J4Wn5Ja0pY2A5x6OpPKt62Kfx3bV6bV3Tkq7bevrzP+dbSkK5DAVL2Z9Pr60t7/KAWPxbHv7E3A9yRNG1ghaRvg2/iRWedcFTTCRN01dBJw1kBHFiC7/VXg09lFYOcAu9anec65ZtUIsTi2M3siMA5YKOkxSY8Bf8/WnZiyQ0ntku6W9KtBtm0r6aYss82tkqaWbNtG0g2SHpA0X9L0lP065xqMWfzS/MYDWw2y/mXZNoBlJJxtqxCL3yLpr5J6s6xjpds8FjvXShogFsfOM/uEpN2BtwI7ZasfMLPfjWCfJwEPAIOdAz4PuNzMLsumAfs6YSoaCKfQvmpmN2ZpdQs+65lzbmMVfW7DGroGuFjSacCd2bo3AN8Ars7u7wk8lFDncLH4ceAY4NRBtnksdq7FFD0WR/8Xb2GAz43ZMiLZkdZ3Ek6NnTJIkRkl628Bfpk9bgbQYWY3Zm1ZPtI2OOcaR4sMIYjxCeB8wgwyA3G7F7iEdR3OB4CPx1RWKRab2aNZuf6yx3ksdq4FFT0WDzvMQNIhkh6VtMF/7pImZtsOTtjft4HTGPo/+XsJV+UCvAuYIGlzYEdgiaSrs9Ni50oadISzpOMkzZE0p7t/dULTnHOFYkC/xS1NzsxWmtkngM2A3bJlMzP7pJmtyMrckzCTwbcZPhYPJSoWl8bhnp4VibtwzhVKA8TiSmNmTwDONbNl5RvMbCnhgoOTY3Yk6Z+AZ8zsrmGKnQrsJ+luYD/gScL8th2EaWlOJZxaewXhFNgGzGyWme1hZnt0tY2OaZpzrqgscmkRZrbCzOZmy4h6iZGxeChRsbg0Dnd2xs8S4pwrqILH4kqd2V2A4cbF3gy8LnJf+wKHSnoUuBI4UNJPSguY2WIze7eZ7QZ8Llu3BFgE3GNmC82slzD8YPfI/TrnGlTRr6CtJUlbSjpL0mxJv5D0ZUlbjqCqirF4GB6LnWtBRY/FlTqzUxj+NJQBm8fsyMzOMLOpZjYdOAK42cyOLi0jabKkgTadQRgPBuGCh0mSpmT3DwTmx+zXOdfACn4Fba1I2peQ5esoYBUh69cHgIcl7ZNSV0wsHobHYudaUcFjcaXO7CLC0dmh7EIYCjBi2ZGGQ7O7+wMPSnoI2JJwcQJm1kc4rXWTpPsI0579cGP265wrvqIfDaih84ArgB3N7INm9kHC+NUrCYkSNlppLJb0BkmLgPcC/yVpHngsdq5VFT0WV5rN4NfAVyRdZ2arSjdk2WfOysokMbNbgVuz22eWrJ8NzB7iMTcyfMfaOddMch6DJWkm8B2gHbjIzM4u2/4J4HjCOP3lwHFmVpSjjrsCx5jZ2jNlZtYv6Xzg7pFWOkwsvhOYOsRjPBY710oa4NqESp3ZrwKHAw9JugD4W7Z+Z8LFYQK+Vr3mbSQjLRVnStWJ9Soxzae649ModqxIq7trWVqqu84l8SkAn102vnKhEo9OjBqlAsDY9jVJdb/Yk3bhyZI1Y6LLak1iOtuErJiQlqJWqVeQJqZWpjeh8Tl+30LWmXwiaHbF/YXAwYQzTndKurass/ozM/tBVv5QwlRYM3NpwMZbCmwHPFi2fjtgSc1bk6LfaFsdn6JUa+I/n6npbC3xs28JcTv1NwGr3sSdqd+apMSqPYlpWBPT/NKdkM52dVpg7ViZ+NvXFf9c+zvSUuX2tye+jinpb3M+3Z9nLK6WYTuzZvaMpDcC3yd0WgdeTQOuB443s6er20TnXMvK7/d+T2CBmS0EkHQlcBgl4z3LZm0ZR7GORVzJuqQJf8rW7UuYUeaKurXKOdcaGj1pgpk9BrxD0qbA9oQO7cNm9mK1G+eca20JRwMmS5pTcn+Wmc0qub818ETJ/UXAXhvsTzqekESgi3BxU1GcRoi9lxDitoBuwoGG0+vYLudcC2joI7Olss7rnRULOudcHixpEu7nzGyPjd+lXQhcKOko4PPAhze2zjyYWTdwkqQzgFdmq/9uZivr2CznXCtIi8V1Ed2Zdc65Wsvx6tgngWkl96cy/EwsVxKOetaNpGsjygBgZodWKOqccyNW9FljvDPrnCuu/E5t3QnsIGk7Qif2CMKcrWtJ2sHMHs7uvhN4mPp6vs77d865oFmGGTjnXE0ZKKeLDsysV9IJhAtX24FLzGyepLOAOWZ2LXCCpLcCPcCL1HmIgZl9pJ77d845INdYXC3emXXOFVeORwPM7DrgurJ1pXOrnpTbzpxzrpn4kVnnnBuhYsdP55xrDQWPxWmz/DrnXA3JLGpxzjlXPXnGYkkzJT0oaYGkDaYWlHSKpPmS5kq6SdK2ler0zqxzrrjM4hbnnHPVk1MsLsnGeAgwAzhS0oyyYncDe5jZLsBs4BuV6vXOrHOumIyQdSZmcc45Vx35xuK12Riz+bMHsjGu253ZLSVzaN9BmEpxWE0+ZtYgIbd2krbEvMqJOcG1Jj7ndMfKtPzUXcvT3vauZfH5rJe/NCqp7qdXTYguu1nnxKS6l/eltWVFd1d84dSPVWKHK+XKUaXmhO9PK5+Ucz7H75vwIQTNQP1G2+qEGJUSK3vSYh+9ieUTPs+W+tm31KAQf+xJiQEq6VumxN++np6k4kp4T5XyuQLaRqf99nWsin/N+zvTXhdL7X0l9TkS36OKtSXF4lyyMZb4GPCbSjtt8s6sc66hJXa8nXPOVUF8LM4lGyOApKOBPYD9KpX1zqxzrpgGTm0555yrn3xjcVQ2xmzO788B+5nZmkqVemfWOVdYPszAOefqL8dYHJONcTfgv4CZZvZMTKXemXXOFZd3Zp1zrv5yisWR2RjPBcYDv1AYo/24mR06XL3emXXOFZRPu+Wcc/WXbyyOyMb41tQ6vTPrnCsmwzuzzjlXbw0Qi70z65wrLr8AzDnn6q/gsdg7s865wvILwJxzrv6KHou9M+ucK66CB1DnnGsJBY/F3pl1zhWTAf3FDqDOOdf0GiAWe2fWOVdQ5hnAnHOu7oofi5u7M2sjyJcdKTXzsXWk5ZBOyU/dtiat7o4VaR/KjuXt0WW1Ir4swIurx0SXfWHMuKS61/Slfbz7+hPeVUv7BCgxDrT1xv8XrN60ytWbmLe9v4r56StWWOyjAS5SwmcuJfYl/8Amfj6tL6F+S2xL8mc7vn7rb0uqWUpoS2q7U2NCtT4rQPuatLb0r4n/PWtfk/aat3em/Yb0d8S/7taW2kOJqbTYsbi5O7POucbVAKe2nHOu6TVALE77V2IjSXpU0n2S7pE0Z5Dtm0q6RtJcSX+R9JrYxzrnmo2Fo10xSwRJMyU9KGmBpNMH2X6KpPlZ/LlJ0ra5P6UCkdQu6W5Jvxpk27eyWHvP/2fvzuPkqsr8j3++3enskAABBggQXDEqBkRAcWQTDeqACyooKijy0wEBERVcEJlRQXAdUCYCAi6gE0EzCgIKDC5sQSBAwhLDFgKEHULI0t3P749zKtxUqrvv6b5Vdavqeb9e99VV956696ntqdPnnnuOpLslPZ3Zdoqk2+PywYYG7ZxrgmJzcT00o2V2DzN7fIBtXwJuMbP3SNoWOAPYK+djnXPtpqBTW5K6Cflkb2AxcKOkOWY2P1PsZmBHM1su6dPAt4F2rqwdBSwA1q/eYGafrdyW9Blg+3j7ncAOwAxgDHC1pEvN7NlGBOyca5KSdzNoaMtsDtOBKwHM7E5gmqRNmxuSc64pKqe28ixD2wlYaGaLzGwVcCGw31qHM7vKzJbHu9cBU4t8OmUiaSrwTuCsHMUPBC6It6cD15hZr5k9D8wDZtYnSudcKRSbi+ui0ZVZAy6XdJOkw2psvxV4L4CknYCtefEHZajHEh93mKS5kuaushUFh++cayizfAtMqXzv41KdI7YAHszcXxzXDeQTwKXFPplS+T7wBYa4qih2tdiG2MhAyNEzJY2XNAXYA9iyxuNezMO9y6s3O+daTf5c3BSN7mbwZjN7SNImwBWS7jSzazLbTwZ+IOkW4DbCab++nI8FwMxmAbMAJnVPKXe7uHNucPmT4+NmtmMRh5R0ELAjsFsR+ysbSe8ClprZTZJ2H6L4AcBsM+sDMLPLJb0B+DvwGHAtL+boNdbKw+M28zzsXKvzbgYvMrOH4t+lwMWEU3/Z7c+a2SFmNgP4KLAxsCjPY51z7SZnS0C+JPsQa7cgTo3r1iLprcCXgX3NbGUhT6N8dgX2lXQfobvFnpJ+PkDZA3ixiwEAZvYNM5thZnsTRim8u57BOueardBcXBcNq8xKmiBpvcpt4G3A7VVlJksaHe8eSuib9Wyexzrn2owRxhHNswztRuDlkraJOeYAYE62gKTtgf8mVGSXFv10ysLMjjezqWY2jfA6XGlmB1WXixfhbkBofa2s65a0Uby9HbAdcHlDAnfONUexubguGtnNYFPgYkmV4/7SzP4o6VMAZnYm8CrgPIURnO8g9Fsb8LENjN051wwFJUcz65V0BHAZ0A2cY2Z3SDoJmGtmc4BTgYnA/8Rc84CZ7VtIAC2g6rWAUNG90Gyt5pYe4C/x9XkWOMjM0kaud861Hp8BLDCzRcDraqw/M3P7WuAVeR/rnGtnxV4da2aXAJdUrTshc/uthR2sRZjZ1cDV8fYJVdtOrFF+BWFEA+dcx2juSAV5tPcMYGbpU+nl3XViefUmNl6sWp27aNeKxOlsV6S9JqNeyP8x6VqR1nNl5er8+06dnrY/cdJhS5iiNnV6WiV+DNVXv+lsU6aLBCBlysgiv28G1sRBuF1BUvNwSgtQ6vS0qX36Uj5/9e4vmLT/1Kl18+e+1Cmr1Z+Wty3ltzI1ltVp5btW5X8du1emvebdo9N+n/pW5S/fVXTNrgVycXtXZp1zra3krQHOOdcRSp6LvTLrnCuvkg8H45xzHaHkudgrs865cjIr/UUHzjnX9logF3tl1jlXXiVvDXDOuY5Q8lzslVnnXGlZyVsDnHOuE5Q9F3tl1jlXUs2dUcY55xy0Qi72yqxzrpyM0l9B65xzba8FcrFXZp1zpWSkj2npnHOuWK2Qi70y65wrJ7O0Qeudc84VrwVysVdmnXOlZSU/teWcc52g7LnYK7POufIqeWuAc851hJLnYiXPVd1CJD0G3F+1egrweBPCqcVjqc1jqa0dY9nazDautUHSH+Nx8njczGYWEI8r2AB5GNrz81wEj6U2j6W2ImIZMA9Da+Titq7M1iJprpnt2Ow4wGMZiMdSm8fi2kmZPkMeS20eS20eS/l0NTsA55xzzjnnhssrs84555xzrmV1YmV2VrMDyPBYavNYavNYXDsp02fIY6nNY6nNYymZjusz65xzzjnn2kcntsw655xzzrk20baVWUkzJd0laaGk42psHyPpV3H79ZKmNfj4W0v6s6R5kq6WNDWz7RRJt8flgyOM4xxJSyXdPsD2DSRdHOO4QdJrMts+K+mOGMcFksaOMJYtJV0laX7c71HNikfS2Lj/W+M+v16jTM33SNIekm7JLCskvXu4scR9dku6WdLv88YRt20l6XJJC+LrOm0kccR93ifptvjc5tbYPth7NOhjXWfJkX8k6YcxT86TtEMjjx/L7B4/r3dI+r+4bsj8MIxY8uS/D8fX4TZJf5f0usy2yZJmS7ozft/fWOdYJkn638xrcEhmW5G/UXly8cGSHsvk3EPj+q0l/SPz/n1qJLHEfQ6Wi98Sj9craf+qbfXIxYPF8r3M63G3pKcz2wp7f1qGmbXdAnQD/wReAowGbgWmV5X5d+DMePsA4FcNPv7/AB+Lt/cEfhZvvxO4gjChxQTgRmD9EcTyFmAH4PYBtp8KfC3e3hb4c7y9BXAvMC7e/zVw8Ahfl82AHeLt9YC7a7wuDYkHEDAx3u4Brgd2yfMeVZXZEHgSGD/C1+YY4JfA72tsGzAO4Gpg73h74kjjiPu5D5gyyPaa71Gex/rSWUuO/PMO4NL4fdwFuL7Bx58MzAe2ivc3iX+HzA/DiCVP/nsTsEG8vU/29QDOAw6Nt0cDk+scy5eAU+LtjWOeG03xv1F5cvHBwOk1HjsaGBNvT4z5Z/MRvk+D5eJpwHbA+cD+VdvqkYsHjKWq3GeAc+LtQt+fVlnatWV2J2ChmS0ys1XAhcB+VWX2IyQHgNnAXpLUwONPB66Mt6/KbJ8OXGNmvWb2PDAPGPYAxGZ2DSEJDWRNHGZ2JzBN0qZx2yhgnKRRwHhgyXDjiPt/2Mz+EW8/BywgVFIbHo8Fy+LdnrhUdyAf6D3K2h+41MyWDzeW2NL6TuCsAYrUjEPSdGCUmV0BYGbLRhJHgsHeI+fWyJF/9gPOj9/H64DJkjZr4PE/BFxkZg/E8kvj3zz5ITWWIfOfmf3dzJ6Kd68DKmeDJhEq5mfHcqvM7Ol6xkJ4vuvF38WJhNexl+J/o4b9WsfXYWW8O4YRnm0eKheb2X1mNg/or3pc4bk4x+9C1oHABfF2oe9Pq2jXyuwWwIOZ+4tZ94u6poyZ9QLPABs18Pi3Au+Nt99DSBobxfUzJY2XNAXYA9iyoLhqWROHpJ2ArYGpZvYQcBrwAPAw8IyZXV7UQeMpmO0J/4U3JZ54CucWYClwhZkNGAtrv0dZB/BiEhmu7wNfoCpB5ojjFcDTki6Kp6JOldQ9wlgg/JBcLukmSYcNFk/2Pcr5WOey8uTKenoFsIFC952bJH20siFHfhi2QfJf1icIrdYA2wCPAT+N3/WzJE2ocyynA68iNBrcBhxlZv3U4Tcq52v9vtgFY7akLTOP3VLSPMLn6BQzG0mjy/cZPBcPpB65OFcskrYmfD4qDR6NrkOUQrtWZlvBscBukm4GdgMeAvpiBe0S4O+EStK1QF8d4ziZ0BpyC+FUxc1An6QNCK0m2wCbAxMkHVTEASVNBH4DHG1mzzYrHjPrM7MZhIrYTsr0/YxqvkeZ57EZ8FrgsuHGIOldwFIzu2mQYgPFMQr417j9DYRuLQcPN5aMN5vZDoTTnIdLekvV9prvUc7HOlcmo4DXE1rA3g58VdIrIFd+GJYh8l+lzB6EyuwXM3HuAPzYzLYHngfWuRaj4FjeDtxCyLczgNMlrV+P36gcr/X/AtPMbDvCKfTzMo99MK5/GfCx4Z4lypmLB1JoLk6M5QBgtpn1ATShDlEK7VqZfYi1/xOZGtfVLBNPW08CnmjU8c1siZm9NyamL8d1T8e/3zCzGWa2N6E/0d0FxbUOM3vWzA6JieSjhL5Ri4C3Avea2WNmthq4iNCfa0Qk9RCS5y/M7KJmxxOP+TTh9P3MqvUDvkfRB4CLYzzDtSuwr6T7CN1R9pT085xxLAZuid1ZeoHfEn7wRiS2gldOuV5M6DaT3T7QezTkY52rkidX19Ni4DIze97MHgeuAV6XLTBQfhiOofJfLLMd4dTyfmZW+U1aDCzOtFjOZoTf9RyxHELogmFmtpBwzcK2UL/fqEFy8ROZ7gRnEf4BqX7sEuB2QqVyOIbMxYMoOhenxLLO2cFG1iHKol0rszcCL5e0jaTRhDd7TlWZOcDH4u39gSvNrKhBd4c8vqQpkiqv//HAOXF9d+VUdkxq2wGFnd6vpnCF7Oh491BCX5tnCafzd4mnKgTsRehXNZJjidDna4GZfbeZ8UjaWNLkeHscsDdwZ1WZmu9RRraf0rCY2fFmNtXMphE+J1ea2VotzoPEcSOhhXTjeH9PwsUswyZpgqT1KreBtxF+ILJlar5HeR7rXJU5wEcV7ELoPvRwA4//O+DNkkZJGg/sDCzIkx9S5cx/WxH+Uf+Ima2pgJjZI8CDkl4ZV+3FCL7reWIh5Ny9YvlNgVcCi4r+jcqZi7P9qPcl5n5JU+NjiGfv3gzcNZw48uTiQRSai/PGImlbYANC62tlXUPrEKVhJbgKrR4L4SrZuwmjCnw5rjsJ2DfeHku4SnwhcAPwkgYff3/gnljmLF68InMs4Uswn3ABwIwRxnEBoY/pasJ/j58APgV8Km5/Y4zhLkIS3SDz2K8TksrtwM8qMY4gljcT+lTOI5y+uiW+Tg2Ph/AFvznGcjtwQt73KG6bRmhB6irwM7M78arVhDj2js/hNuBcYPQIY3gJoc/VrcAdmc/ukO/RQI/1pXOXHPlHwBmEPHkbsGMjjx/LfJ6Qb28nnG4fMD+MMJY8+e8s4KnM9rmZx88A5sbH/zabG+sUy+aEStBt8TU4KK4v+jcqTy7+VswptxJabreN6yv579b497CCPje7UzsXvyF+jp4nnMm9I/OYQnPxULHE+ycCJ1eVL/T9aZXFZwBzzjnnnHMtq127GTjnnHPOuQ7glVnnnHPOOdeyvDLrnHPOOedalldmnXPOOedcy/LKrHPOOeeca1lemXVuhCTdJ+nYZsfhnHPOdSKvzJaUpE0l/UDSPyWtlPSQpEslvaPZsZWJpGmSTNKOOcp+WdLfJD0vycekc84559qAV2ZLSNI04B+EubGPJwwq/VbgD8CZzYus5Y0hDPL//SbH4ZwrIUnnSvp9g4+5gaRHJb20kcd19SHpfyR9rtlxdBqvzJbTj+LfHc3s12Z2l5ktMLPTCRVbIEx9KOliSc/F5SJJUzPbT5R0u6SPxVPhz0v6qaTRkv5d0oOSnpD03cx0qZXT5idK+rmkZZIeqT6NnnDsA2Lr8nOSfitpStV+DpE0X9IKSXdL+mxVLCbpsJggnpe0SFJ2Wr97498bY9mrB3pRzewEM/sOYbaZXCRdLenM2Er+VFxOzcYYjZX035KelbRY0uer9nOMpHnxOTwk6azKFI5x+yRJP5O0NL4WiyQdXbV9Vtz+nKT/y9Ma7ZwrvS8Bl5jZPysr/MxcfjFHnz7I9rdImhNfQ5N08CBlN5b0o/gbuDL+k/FnSXtnypwb91O9zIhFTgK+LGlSUc/RDc0rsyUjaUNgJnCGmS2r3m5mT8dyXYR5xTcF9ojL5sBvJSnzkGnAfsC7gPcC7yfMh/4G4G3AocBngPdUHeoYwvzXOwBfA74p6b3DOPYH477fBmwPfCPzXD8JfBM4AXgV8Dngi8C/V8VyQjze64BfAecozGEOsFP8OxPYLD7Hon2Y8F15I/D/gMOAo6vKfJYwjeEOwCnAtyW9MbO9Pz7m1cCHYtz/ldn+n8BrCe/TK4GPE6bLrcyj/gdgi7h9e+Aa4EqtPWe5c66FSBpPyMFnZ9ZNw8/MFWkiYZrco4AXhij7G0Ju/gTwCkK+vRTYqKrcnwi/N9nldgAzuw1YBByEa5xmz6fry9oL4YtkwHuGKLc30AdMy6x7CaHS9NZ4/0TCl3dSpsxs4DEy80YDVwOnZ+7fB1xRdbyzgL8mHntF1bG/DCzM3H8A+EjVcY4G5mfuG/CtzP1RwHJenCd8WiyTe053YP/w0c9V9mrgbghTP8d1XwEWV71eF1Q97h7gK4PsdyawEuiK9+cA5wxQdk9gGTCuav0twBea/Zn1xZd2WYBzgd/H22MIXZIejbnsOuDNVeUnAOfH7+ejhMrn74Fzcx5vf+DJqvxyCeEf2Yk1yk/O3B40vpi7fgx8Jx7jMUKFbgxwBvD0ADn4akKl+QfAU3E5tZKrEl6bqwlnGb8JPA4sBU7L5DwBXwD+Sfiduq2S1xP2cS4h/2eXaYO83suAgwfYNjk+/q15PyODlDmB+HvpS2MWb5ktHw1dBAgtmUvM7L7KCjNbBCwBpmfKPWBmz2TuPwrcbWarqtZtUrX/a2vcr+w377Hvrzr2kspxJG0MbAn8d+zKsEzSMuBkoLrv2LzMcXoJSbk63nq6zmKGiq4FtpC0fmbdvKrHrHmuAJL2lHRF7ILwHKHv7mjgX2KRHwMflHSrpNMk7ZbZ1+uB8cBjVa/Va1j3tXLOFePbhDNLHyecDbkN+GPV2ZDvALsRzj7tSTh79K8Jx/hX4KZKfsl7Zi4hvg8DzwE7E3Lr94HfEv5B3xE4Dzirxhmeoc5G5Tl2ZT+9wJuAI+I+Phi3/SehBfRwwu/Gtwi/B+9M2MdRhHz8U15sIX2Q4VkWl30ljR3mPipuAHaSNG6E+3E5eWW2fO4h/Hf4qhHsI1vxWl1jW611RX0Whjp25TiVv58CZmSW1xBOxWfVM96iDBijpK0JpwgXELp5vJ7wIwChQouZXQpsTWh1mAL8QdJPY5kuwj8cM6qWbYGvFv9UnOtskiYAnwa+aGZ/MLMFhFz1KKHyhaSJhO/xF83sCjO7g1A568/sZ8vYp3N+7DP//qpDbU34x7fiZYQGjQUjjS+6w8xONLN7gO8SWjdXm9kPzGwhoX+ngF2rDvEwcKSZ3Wlmvya0zB6TeGwIZ9lOMLO7436uAvaK+zgGONTM/mhm95rZL4Gf5N0HQGwsWQUsN7NH4tI32Gs3kNhQcjChe8DTkq6NDQs71yg+M9uwIOnSqu1LgB5C9zvXAGWrEHQ8M3sSuAw4IibLtWQuGloAbB77V1W2vYTw5ZlfQCi71LhfSbAjPraZPUr4wr/UzBZWLwlxVlqYuxMek2rnqr7AuxBapp/N+fgdCZXWz5rZtWZ2NzWSnJk9bmY/M7ODCT+KH5M0htB/blOgv8ZrtXQkT8w5V9NLCZWRv1VWxEpS9gxVpcwNmTLPE/tORr3A0WY2nXDdwPdjRa5iHOE0fUXeM3N54oO1z2oZ4TT9bZl1qwndCKrPdA12Nirvsdc6flQ5YzUdGEtozc2ebfo0g5yZq9pH4czsN4Tc/G+EvrJvAq6T9KWqotewdsPCoVXbK31zvWW2QUY1OwBX0+GERDFX0lcJX2YRLrQ6HtiK0AF9HvALSUfFx/0XoeJzZQEx7CLpeEIf292BjxJO91Dgsb8G/Jekpwn9xHoIF1BtYWbfyrmPpYTE8XZJ9wErqro2rBEvGtuQ0M+WzNWnC2ud0svYnPAj9CPCRVqfJ5wiy+sewj+OR0u6iFAZProqtpMIr98dhO/le4FFZrZS0p8In4ffSfoCcCehe8JM4E9m9peEWJxzI5N7jGoze5jQyomZPSLpcUIOej4WeRzYIPOQ7Jm5iwuIr5ln5gY6flfmeP9G6Lc72GMaembOzFYAV8TlJElnASdKOi3TPW/5EI0uG8a/j9UrTrc2b5ktodj/dAfCl+kUQsXxSmBfQt+lyn/Z+xG+LFfF5RHg3VX/UQ/XdwlX0d5MqLidYGazizy2mZ1FOE33EeBW4C/x+d072OOq9tELHEn4z3gJYdSDgZwUn8+p8f7NcRlqiKtfEFp+ryecBjsb+F5CjPMIfbuOIbRcHwpUzxi2kjDSw62Eiut6hERfeb3fQfgM/AS4C/g1YdSDJTjnivZPwlmfNaffJXUT+pDOz5RZTRgZplJmPKGr1DokvR7oNrNsn86bybRmJpyZyxPfSAx2NqqIY88n5Lyta5xtuj8x1lXU98zcfEIDQ0o/2tcAD8UzkK4Rir6izJfWXwhX5x/b7DjKsFA10oMvvvjSvgtrj2bwfUKr6jsILaWzCBcIbZYpf2bMl3sRKqW/BJ4Bflq13w0JZ13eVLX+tYSRYTbKrHtJPO6dhD72ryT0j/804YJe8sRXK3cRukCcWLXuEeCIzP2rCReN/SAee3/CyAfH5j32IMfPvr7/CTxBaNB4GeF0/aeAw/LuI96fBdxEOOM2hcyoC3H7RF7sDrCcMNLADGCrqnIbERoMDiI05GwTX/9HyIzuU338QT5HZzf789xJi3czcM4559b1xfj3p4Rhm24GZlroOlBxLGF4rjmEytz3CP3b1/SDjf3efwucbGZ/zx7AzG6TdANwAGG4LMxskaQdCJMpnEIYX/oJwlmbwxLjG67s2Shj3bNRRRz7q4SLxo4ljObyLGG4wW8nxnoaYVSG+YQ+qtsQ/sGo2JFw9rDi63E5j3DBV8UywhBjRxEq12MIQ6T9koRuZXEkhPcQxgl2DaL4X4Rza8S+p6eb2WnNjqXZFGYUu93Mjmh2LM65cosV1/uBU83sO/FU/S+Bu8zsxAEeM5PQCjrdhnklfpE8542MpMOB/czsbc2OpZN4y6xbh5lNa3YMZWFmuzc7BudcOUnannCa/QZCP/cvxr+/ikV2JYyJOk/Su+O6j1iYJQoAM/ujpDOAqYSKsGttqwmzaroG8sqsc845N3zHEPqW9hJOk7/FzBYDmNlfyXGhtZn9sJ4BusYxs1nNjqETeTcD55xzzjnXsnxoLuecc84517K8Muucc84551qWV2adc84551zL8sqsc84555xrWV6Zdc4555xzLcsrs84555xzrmV5ZdY555xzzrUsr8w655xzzrmW5ZVZ55xzzjnXsrwy65xzzjnnWpZXZp1zzjnnXMvyyqxzzjnnnGtZXpl1znUESedIWirp9gG2S9IPJS2UNE/SDo2O0Tnn2lm98rBXZp1zneJcYOYg2/cBXh6Xw4AfNyAm55zrJOdShzzslVnnXEcws2uAJwcpsh9wvgXXAZMlbdaY6Jxzrv3VKw+PKirAMhrdNdbGda+X/wFKqNuP6k6KpW9sWvnV61vusluuN9jnYl2TuvqSyj/Xr9xlH1u9ftK+l68cnbusVuaPA6B7VVJxulblf83V15+0b/Xn3zcA/Qn7T923JZZPkfYW8Wzv44+b2ca1tr19jwn2xJP5Pqs3zVt5B7Ais2qWmc1Ki4YtgAcz9xfHdQ8n7sdljNYYG8uE3OWVkFttdE9SLDYqrf3GuvN/oC3xs5/6XbGEn5D+tJ+bpH3TnZg/utLKdyWUl9L2rcTXXCTEkrbrhD2ns8Rolt/zyIB5GBqei4eVh9u6Mjuuez3eOPm9uctr3LjcZfs3Squ0PfvKSUnll7ytN3fZ03b7ZdK+9xn/XFL5a1bkr3D+eMkeSfu+aeHWucuOvXdM0r7Xvy8tXUxYkr/2O/rplUn77no+rbyWrxi6UGQr0vbNqtVp5S2hYt2d9it62eOz7h9o2xNP9nHDZVvlO+xm96wwsx2TDu4aYiwT2Fl75S7fPXnD3GX7t0prOF+5Sf4cD7Bq/fyf574xaRWIvp608qsn5i+/anLSrlm5Qf7veP96aY0h3RPS8s3YsfnLj+lJ2/foUWmx93Tlf126EivW/Yn//aSU7+1P+6ftxn1OHjAPQ2vk4rauzDrnWpcB/aS1gI/QQ8CWmftT4zrnnOtYDc7Fw8rDpegzK2mmpLvi1WvH1dg+RtKv4vbrJU1rQpjOuYYy+qw/11KQOcBH49W0uwDPmFlHdTHwER+cc+tqaC4eVh5uesuspG7gDGBvQt+IGyXNMbP5mWKfAJ4ys5dJOgA4Bfhg46N1zjVKaA0ormeZpAuA3YEpkhYDXwN6AMzsTOAS4B3AQmA5cEhhB28d5wKnA+cPsD17pfHOhCuNd25IZM65pigyF9crDze9MgvsBCw0s0UAki4kXM2WrczuB5wYb88GTpcks3peyeKcaybDWG1pfdwG3Z/ZgUNsN+Dwwg7YgszsmiHOfK250hi4TtJkSZt1Wgu2c52kyFxcrzxchm4GA125VrOMmfUCzwAb1dqZpMMkzZU0d1V//otonHPl04/lWlzD5MnXa+Xh1SReoOicK52y5+IytMwWKg4BMQtgUs/G/ivnXIsyoM8rqi0pm4fX14b+JjrXwlohF5ehMpvnyrVKmcWSRgGTgCcaE55zrlm81bV0fMQH5zpQ2XNxGboZ3Ai8XNI2kkYDBxCuZsuaA3ws3t4fuNL7yzrX3gzoM8u1uIbp+BEfnOs0rZCLm94ya2a9ko4ALgO6gXPM7A5JJwFzzWwOcDbwM0kLCdOgHdC8iJ1zjdLQUWadj/jgnKup7Lm46ZVZADO7hJAks+tOyNxeAby/0XE555rHsNL302o3PuKDc65aK+TiUlRm68ZIm7e+L2Hoib7E+aZ7Ez8Iq/P3AHmyb2LSrh/vW5pU/pHeTXKXfWZV2nSRrMw/XWR34kXR3SvTXvPuFfnf/64X0qZR1Ir8U+UCaVPO9uaf+hhI+5wDKT16pAJ7Llny18x1mtSPm9KmEHU1JE7bWs9XvCtx56lTzqaUV+K+uxPLkzBFbWosQ2qBXNzelVnnXMsKA3U755xrplbIxV6Zdc6VlOira7uOc865oZU/F3tl1jlXSgastnInUOeca3etkIu9MuucK6UwUHe5E6hzzrW7VsjFXpl1zpVWf8lbA5xzrhOUPRd7ZdY5V0qt0BrgnHPtrhVysVdmnXOlZIi+UkxS6JxznasVcrFXZp1zpVX2U1vOOdcJyp6LvTLrnCulVji15Zxz7a4VcrFXZp1zJSX6rNyntpxzrv2VPxe3eWXW0qbuTJm2sz9tPgylTn+7Mv8H59HVk5L2vaRvdFr51ZNzl336hbTpbLteyP88R72QtGt6lqe9R90rEqaFXZk4Pe2KtLl4bXXCdLar06aztcTpbJMUuO8w60y5E6gbmiS6xo7NX76nJ3dZ68k/HTZA/6i01iXrzl/eEudWTa0bWMJTTSmbXL478besOy0Pjx6VP5+llAUYm1h+THf+8qO60p5nF2mvY39Cy2hvwtS3ebRCLm7zyqxzrpWV/dSWc851grLnYq/MOudKyUysTm1ics45V6hWyMXlbjd2znWscNFBV64lD0kzJd0laaGk42ps31rSnyXNk3S1pKlFPyfnnGs1rZCLvTLrnCupcNFBnmXIPUndwBnAPsB04EBJ06uKnQacb2bbAScB3yr4CTnnXAsqfy72yqxzrpQqFx3kWXLYCVhoZovMbBVwIbBfVZnpwJXx9lU1tjvnXMdphVzslVnnXGn1mXItwBRJczPLYVW72gJ4MHN/cVyXdSvw3nj7PcB6kjaqx/NyzrlWkpCLh1KXXOwXgDnnSilxCsXHzWzHER7yWOB0SQcD1wAPAXUcx8w558ovMRdPkTQ3c3+Wmc1KPGRyLvbKrHOutPqLG6j7IWDLzP2pcd0aZraE2BogaSLwPjN7uqgAnHOuVSXk4qEaFuqSi72bgXOulAq+gvZG4OWStpE0GjgAmJMtIGmKpMrOjgfOKfL5OOdcK2qFXOyVWedcKRn5+mjl6adlZr3AEcBlwALg12Z2h6STJO0bi+0O3CXpbmBT4Bv1eWbOOdc6WiEXezcD51xpFTmFopldAlxSte6EzO3ZwOzCDuicc22i7Lm4vSuzBmYJ8x/3Jcyt3Jt2XUjXqsT5rFfmnzpu6ar1kvZ93+opSeUfXLFh7rLPLR+TtO/uF/I/z1HL017D7hcS36MXVucuqxdWJu3bVqSVpy9/7NabNt84/WlziKewriITXvlnnXE5jBpF15T8g0LY+LG5y66e2JMUyuoJaZ/P1ePy56f+0Um7JrU7eF9Cau0bm5YrbVz+fNMzLn+eBJg4fkVS+fXH5s+Vk0an7XtiT1oeHted/7mO616VtO8epf0+jeqqX96+bIjtrZCL27sy65xrWQa5BuF2zjlXP62Qi70y65wrrYThYJxzztVJ2XNxQ6MbyXy8kk6RdHtcPtjIuJ1zjWeIfsu3uPwknSNpqaTbBymzu6RbJN0h6f/iurGSbpB0a1z/9cZF7ZxrllbIxQ2rzI5kPl5J7wR2AGYAOwPHSlq/QaE755qkwOFg3IvOBWYOtFHSZOBHwL5m9mrg/XHTSmBPM3sdIRfPlLRLXSN1zpVC2XNxI488kvl4pwPXmFmvmT0PzGOQZOyca31GGKg7z+LyM7NrgCcHKfIh4CIzeyCWXxr/mpkti2V64pJ2pZFzruW0Qi5u5JFHMh/vrYRWgPGSpgB7sPYMEmtIOqwyP/sqS7vS0TlXJqIv5+IK9Qpgg9jV6yZJH61skNQt6RZgKXCFmV1fawdr5eH+FxoTtXOuTsqfi8t2AVjN+XjN7HJJbwD+DjwGXMsA8/TGOYBnAUzqnuKtBs61qEprgGu4UcDrgb2AccC1kq4zs7vNrA+YEbsiXCzpNWa2Tt/btfLw6E09DzvXwlohFzeyMjui+XjN7BvEWSAk/RK4u/4hO+eayVtdXyRpDLA5oYL5mJk9VqdDLQaeiF26npd0DfA6MjnXzJ6WdBWhu9eAF5I559pD2XNxI6vaw56PN57a2ije3g7YDri8YZE75xrOTKXvp1VvktaT9OlYoXwGWEioPD4i6QFJP4lnrYr0O+DNkkZJGk+46HaBpI1jiyySxgF7A3cWfGznXMm0Qi5uWMusmfVKqszH2w2cU5mPF5hrZnMI8/F+S5IRuhkcHh/eA/xFEsCzwEFxfl/nXJsyKP2sM/Uk6Rjgy8Aiwj/+3wCWAC8AGwKvAf4VuELSdcBnzOyeHPu9gJBrp0haDHyNkGMxszPNbIGkPxIutO0HzjKz22NDwnlxZJouwpzqvy/yOTvnyqcVcnFD+8wOdz5eM1tBGNHAOdcxVPpZZ+psF2C3Wn1SoxuAcyR9CvgEsBswZGXWzA7MUeZU4NSqdfOA7Yd6rHOu3ZQ/F5ftArDipcxDbwllE+e37+pLuwaiK2Ga58dWTUza95LVGySVf2RF/iF9V72QNlf62Bfy98MZtSLtNe9emTiX9ar883BbQtlQPm3ebizh85L4WbSUfSdSYiyDCRcdlLufVj2Z2QdylltJGBe2lKynm76NJ+d/wKj8P5qrJqf9hK1aL+3z1Dc6f/n+MUm7JvWj3Tc2f9necWnf8e4J+U90rjchbZSgjSc8n1R+ytj85TccnbbvjXrSyk8atTx32fW60l6XsV1pvyFjlb98j9JOXJ82xPZWyMW5s4akTSUdK+nHcXgsJO0qaZv6heec62RlH6i73iRtl7mOwDnnmqLsuTjXkSW9HrgL+DDhdFalqW5v4ggDzjlXpFaYQrEBbgamVO5I+oOkzZoYj3Ouw7RCLs5bjT4N+IGZbU+Y0rDiMmDXwqNyzjmgn65cSxur/nV4C2FoLueca5iy5+K8HY5eT2iRrfYwsGlx4TjnXGAGfe3d6uqcc6XXCrk4b2X2BaDWVUPbEqY1dM65wrV5F4I8LC7V65xzrmHKnovzVmZ/B3xN0vvjfZM0DTgF+E09AnPOdbbQT6utuxDkIeDnkirdu8YCP5G01mXWZrZvwyNzznWEVsjFeSuzxxLGh30MGA/8ldC94G/AV+oTmnOu05V9CsUGOK/q/s+bEoVzrqOVPRfnqsya2bOE6Q33BHYgXDj2DzP7Uz2Dc851rqLHNpQ0E/gBYQbCs8zs5KrtWxEqj5NjmePiRC9NY2aHNPP4zjnXCuPMJo04bWZXAlcCSEobHd8555KI3oKmUIxTsJ5BGE5wMXCjpDlmNj9T7CuEKVp/LGk64WzUtEICKJikUcBYM1vW7Ficc+2uuFwM9WlYyDvO7JGS3pe5fzbwgqS7JL0y6Vk451wOlSto8yw57AQsNLNFZrYKuBDYr/qQvDiG9iRgSWFPZpgk7SXpA1XrjgOWAU9L+qOkyU0JzjnXEYrMxZmGhX2A6cCBsfEgq9KwsD1wADlmOMzbMnsk8PEYyFuADwAfAt4HfAd4V879NF7K1J0JZdWfdkGxUqez7cvfpP/sqrRhJx/vTZv+9pmV+fdvK9L+e0uZtjdx9j/Umza1qlbnnwLQetOmC6SvL6l4PaecJfGzm6TguBMuOpgiaW7m/iwzm5W5vwXwYOb+YmDnqn2cCFwu6TPABOCtadHWxXHApZU7knYCvgmcDSwAPg98Of4tp+4ueiclzvWaU+/Y+k1PC9A/OmXfSbsm9XqavrH5v1s2Ni3fjBmbPxFPHpc2bWvK9LQAW4x7OnfZzUbnLwuw8ajnkspv1J3/xMfkrvxT3wKsl/LjB4xX/ve0pw49Agq8AGxNwwKApErDQvYsWXLDQt7K7BbAvfH2vwH/Y2a/lnQb8Jec+3DOudwqs87k9LiZ7TjCQx4InGtm35H0RuBnkl5jZmn/FRXrtYQKbcX7gb+b2ScBJD0I/Cdlrsw651paYi5uSsNC3srss8AmMYC9gVPj+tWEoWKcc65w/cVdQfsQsGXm/tS4LusTwEwAM7tW0ljCVLLNHEt7ctXxdyX05a24kfDj4JxzdZOQi5vSsJC33fhywtiGZwEv48XTXq/mxRZb55wrTOUK2oLmA78ReLmkbSSNJvTDmlNV5gFgLwBJryL8o/5Ycc9oWB4GXgogaQywPXBtZvt6rD3FuHPOFargXJy3YeHXEBoWCLl4ymA7zVuZPZwwpuzGwP5m9mRcvwNwQc59OOdckn7ryrUMxcx6gSOAywh9TX9tZndIOklSZcKBzwGflHQrIa8dbHXtvJzLpcC347CIpwDPs3bXru2Ahc0IzDnXOYrKxdSpYSFlnNnP1Fj/tTyPd865ZPn/08+3uzC0yyVV607I3J5POI1fJicAFwF/Ioxg8LE4GkPFx4ErmhGYc65DFJiLzaxXUqVhoRs4p9KwAMw1szmEhoWfSPosoWF4yIaFpHFmAST9C7DWdZtm9kDqfpxzbjBGoX1mW5KZPQ68RdIkYJmZVV/S/H5CJdc55+qi6Fxcj4aFXJXZmEh/SBiSq9YAJMWNpuucc1HZZ51pFDN7ZoD1T9Za75xzRSp7Ls7bMnsa8Drg3YRTXh8nXEF7FKE52DnnCmVAb39hYxs655wbhlbIxXkrs/sAB5rZXyT1ATeZ2a8kPQz8P2B23SJ0znWkxLENnXPO1UEr5OK8Ve3JwP3x9jPARvH2tcCbCo7JOeeA0E8rz9LOJE2W9E5Jb5Kkqm0TJJ0w0GOdc64IZc/FeSuz/wReEm8vAA6ISfW9gPfZcs4Vzwod27AlSXo1Ief+DvgrcKOkrTNFJgI+qoxzrn5aIBfn7WZwLmE8w6uBk4HfE8Zs7CL0m20PKXPWJw4/qZR9A+rNX3ZFX9qgFMt60+ZJX7Y6/6Tj6k3rV9O1OqFsb9pr2NWbOAtpX0L5vrS5zy1l3/WWOjurmtNXqjJQd4f7FuEM2EcIc5X/APibpD3M7J6mRpaTCXrH5b9GuGt1/s+nqc6fj4Tdp05db4mXTff3JOS/0Wnf8TE9+X9wJvSsGrpQxuSeF5LKT+l5LnfZfxlV87rIAW3e81RS+Y27lucuO7kr7TVfryvtd3ucxucu211wzm6FXJx3nNnvZW5fKWlbYEfgHjO7rV7BOec6W9kTaAPsAuxhZs8TJkz4gKTvAldL2oPQ7cs55+qq7Lk4eZxZWDOurI8t65yrm1a46KABxhAaRtYws2NiN6+rgQ81IyjnXOdohVycuzIraWfC9GKbUNXX1syOzPH4c4B3AUvN7DU1tm8AnEOYh3wF8HEzuz1u+yxwKCGp3wYcYmYr8sbunGtNVvIE2gB3Ec6Czc+uNLPPSuoi9KVNImlL4HxgU0JOnWVmP6gq82Hgi4QT7c8BnzazW+O2ycBZwGvi4z8e5093zrWpsufiXB0rJB1L6Ld1MDADeG1mWadiOoBzgZmDbP8ScIuZbQd8lNA3DElbAEcCO8ZKcDdhLl/nXJsr+xW0DXAxcGCtDWZ2FPBzknp2AtALfM7MphO6MRwuaXpVmXuB3czstcB/ALMy234A/NHMtiWMP74g8fjOuRZT9lyct2X2KOBIMzt9uAcys2skTRukyHTCxWWY2Z2SpknaNBPnOEmrgfHAkuHG4ZxrDWbl76dVb2b2LcJFYANtPxw4PHGfDwMPx9vPSVpAmARnfqbM3zMPuQ6YCmtmg3wLoWEDM1sFpF0R5JxrKa2Qi/Ne8rY+VfPo1sGthKG+kLQTsDUw1cweIsxA9gAhAT9jZpcPtBNJh0maK2nuKu+J4FwLE339XbkWNzyxgWF74PpBin0CuDTe3gZ4DPippJslnSVpQo39rsnDq1c9X3TYzrmGKn8uznvkCxi8i0ARTgYmS7oF+AxwM9AX+9LuR0iimwMTJB000E7MbJaZ7WhmO47W2DqH7JyrJzPlWlw6SROB3wBHm9mzA5TZg1CZ/WJcNQrYAfixmW1PGGHhuOrHZfNwz+h16rrOuRZT9lw8YDcDScdk7j4IfF3SrsA8YK3RQc3suyMNJCbTQ+KxReiztQh4O3CvmT0Wt11EmHXs5yM9pnOuvFphbMNGkbQV8KDZ2gNcx1y5ZRxhJmV/PYSK7C/M7KIBymxHuNBrHzN7Iq5eDCw2s0pL7mxqVGadc+2jFXLxYH1mP1N1fxmhElk9fa0BI67Mxitkl8c+WIcC15jZs5IeAHaRNB54gTCiwtyRHs85V3KWPDdJO7sX2AxYWrV+w7gt9xD8sQJ8NrBgoIaIWHm+CPiImd1dWW9mj0h6UNIrzewuQj6eX2sfzrk20QK5eMDKrJltU+SBJF0A7A5MkbSYMAVjTzzWmcCrgPMkGXAH4dQWZna9pNnAPwhX4d7M2lfWOufaVJuPVJBCVI03G00kDGWYYlfCjGK3xW5dEEaT2QrW5OMTgI2AH4W6L71mtmMs+xngF5JGE86eHZJ4fOdciyl7Lk6eNCH2s8LMlqU8zsxqDi+T2X4t8IoBtn0Nn3/cuY5ilH9sw3qT9MN404BvScrOr9kN7ATckrJPM/srQwznZWaHEs6Q1dp2C2HsW+dcB2iFXJwyacLRwDGEIVyQtITQveD71f24SsMM+hPnoU/ZdwL1J5bvy192dX/aJN8r+3uSyq/qTfifpzftA5/yPJX6VqZ+LBPKW19C4MMon0JddU4ylvDCF/p9K/+sMw3w2vhXhLNX2WGwVhHOWJ3W6KBSKeGrmFK2e1Xad7w7cRAx687/+UvNT5aWtpOojl+brponCAY2qist9/Uk/CiM7Vo9dKGM0aTFMjrhTe1JfNG7cl9/H/SnvO4pOTuX8ufiXLUUSd8GDgNOJUyeAPBGwqmozYAv1CU651xHK+m/yQ1jZnsASPopcNRAow4451w9lT0X521yOxQ41MxmZ9ZdKeku4L/xyqxzrg6KPLUlaSZh9qpu4CwzO7lq+/eAPeLd8cAmZja5sABGwMy8X6pzrmnappsBYUiuWut8xHLnXOHMikugkrqBM4C9CcNL3ShpjpllZ736bKb8ZwiTCZSGpA8SRg/YhKq8a2b7NiUo51zbKzIXQ30aFvJWZs8nTJl4VNX6TwM/y7kP55xL0tdfWALdCVhoZosAJF1ImIxloGGlDqREF51KOhU4GriKMJ13yU/6OefaSVG5uF4NC3krs2OAD0l6O2GeboCdCTNy/SJzxS1mdmTOfTrn3KASWgOmSMqOPz3LzLJD+G1BmPylYjEhh61D0taEGQevTAi13j4KHFjV1cs55xqiwJbZujQs5K3Mbku4ahZg6/j3kbi8KlPOWwucc4UwkqZHfDwzDupIHQDMNrP6DUGRrovEIbicc64Iibm4KQ0LuSqzlStqnXOukQr87/ghYMvM/alxXS0HELpVlcks4CDgxCbH4ZzrQAm5uCkNC8mTJjjnXEMUe9HBjcDLJW1DqMQeAHyoupCkbYENeHEIwrKYTOjqtTfhwtu1Btj07l3OubopNhfXpWHBK7POufIqqGnWzHolHQFcRriC9hwzu0PSScBcM5sTix4AXFjCiWCm82I3g22rtpUtVudcuykuy9SlYcErs8650ipyOBgzuwS4pGrdCVX3TyzsgAXyrl7OuWYqKhfXq2GhrSuzYT7h/P9OKGUKuNSGmzrNqgskTzPXP/i07OtIGZIjdUrHtGkuS9QAlTxVbv0+AHW/TEkJQ0kX/B6V6S13wyOD7hX5P6Tqy/+m9yxP+171j0qcQjThF7JrdeKPfWLxroSpwvtWpz3P1X3559Z9oTdtOvTnVo9NKv/MqPG5yz7RNTFp312JP8SryP+6PNe/MmnfKdP2hvJpU/cWrchcXI+GBZ/wwDlXSuGfUeVaOoGkfST9QdICSVvGdYdK2qvZsTnn2lcr5OIRVWYldUnaqqhgnHNuDQNM+ZY2J+nDwK+Bu4FpQKV5rBufTtw5V08tkIsHrcxKGivpTEmPSbpbUvUMYBsD99YvPOdcJ7P+fEsH+ALwyTgzTm9m/XXAjKZE5JzrGGXPxUP1CDoBeFf8Own4iqQ3AB81WxN2+zeLOOeaoHO6EOTwcmpf1bsMWL/BsTjnOkr5c/FQ3Qw+SGgN+LGZnQzsCOwA/FJac1WIX6LhnKsPy7m0vyXAK2qsfwvwzwbH4pzrNCXPxUNVZjcDFlTumNn9wB7Aa4ELebHflnPOFcvKf9FBA80Cfihp13h/S0kfA74N/Lh5YTnn2l4L5OKhuhk8DLwMuK+ywswejVfPXgWcX7/QnHMdrzNaXYdkZt+WNAm4AhhLyL8rgdPM7IymBueca38lz8VDtcxeRY2ZGczsEWBPwjRkzjlXJ8q5tD8z+zIwBdgJ2AXY2My+2tyonHOdody5eKiW2f9g3akTATCzhyXtBryt8Kiccw5K3xrQSJI+COwFbEJsiJDCj4eZ7du8yJxzba/kuXjQymzsI3v/INsfBs4rOijnnANKn0AbRdKpwNGEs2VL8FfGOddIJc84bT2drXOuhVUG6nYAHwUONLPZzQ7EOddhWiAXt39ltj/h34mUsn1powMrsXxX79BlXgylvrMSSwmvS+LnPeX7Yarzlyll8un+xNGhi5zYutFSXvaU71AOrfyyFawLuKXZQQxLv9G9PP+88inppntld1Ioo1am5ZDesfnLd69K2nXS8wToSohdK9N+E1a8MDp32adGj0vad093X1L5roQXZmV/WhXmyZ4JSeUndb+Qu+xYpX0ARivtdamvh4csUfZcXN9akHPOjUS/8i3tbxZwULODcM51qJLn4vZvmXXOtazU1qs2Nhn4kKS9gXnAWk2dZnZkM4JyznWGsufiXC2zkq6UNLnG+vUlXZlzH1tKukrSfEl3SDqqRpkNJF0saZ6kGyS9JrPts/Fxt0u6QNLYPMd1zrWovDPOlDzJFmQ6oZvBKsIIM6/NLK8Z+GHrypmLJ0n6X0m3xjKHZLadEvPw7XGEBedcO2uBXJy3ZXZ3oFanmrHAv+bcRy/wOTP7h6T1gJskXWFm8zNlvgTcYmbvkbQtcAawl6QtgCOB6Wb2gqRfAwcA5+Y8tnOu5aj0Fx00ipntUeDu8uTiw4H5ZvZvkjYG7pL0C2BvwpTmM4AxwNWSLjWzZwuMzzlXKuXPxYNWZiXtkLm7naQnM/e7gbcDD+U5UBzG6+F4+zlJC4AtgGwCnQ6cHMvcKWmapE0zsY6TtBoYTxiexjnXzjqj1bWhcuZiA9ZTGMh2IvAkoRI8HbjGzHqBXknzgJnArxv4FJxzjVbyXDxUy+xcXmw8vrzG9heAz6QeVNI0YHvg+qpNtwLvBf4iaSdga2Cqmd0k6TTggXjMy82sVjxIOgw4DGAs41NDc86VSckTaCPFf+wPJ1QojVD5/JGZPTqCfU6jdi4+HZhDaDRYD/igmfVLuhX4mqTvEBoV9mDtSnBlvy/m4dGThhuec64sSp6Lh+ozuw3wUsLgPDvF+5VlC2B9Mzsn5YCSJgK/AY6ucWrqZGCypFsIleSbgT5JGwD7xeNuDkyQVPPKXjObZWY7mtmOPd6t1rnWVvJ+Wo0iaVdgIWF68ReAFcCHgXskvXGY+xwsF7+d0Ed3c0KXgtMlrR8bES4B/g5cAFwLrDPG0Fp5OHE4JOdcCZU8Fw9amTWz+83sPjPrMrO58X5ledjMkgZKk9RDSJ6/MLOLahzvWTM7xMxmEAYJ3xhYBLwVuNfMHjOz1cBFwJtSju2cazGVgbrzLDlIminpLkkLJR03QJkPZC6M+mWRT2eETiNUHl9hZh8xs48ArwAuBL6TurOhcjFwCHCRBQuBe4lTm5vZN8xshpntTWjouHtYz8g51xoKzsX1kHtoLklTgbeQmRe8wsy+m+PxAs4GFgxUPo6YsNzMVgGHEvpmPSvpAWAXSeMJrRJ7EbpAOOfaWFHDwUjqJlxQujewGLhR0pzsRU+SXg4cD+xqZk9J2qSYoxdiBnCwma2ZrSOe9v8u4QxWbnlyMaFL116ELl+bAq8EFsXXcbKZPSFpO2A7andBc861kSKH5pI0E/gB4dqrs8zs5BplPgCcSKhK32pmHxpsn7kqs5I+DJxDuADgMdZuTDZgyMossCvwEeC22I0AwugFWwGY2ZnAq4DzFKacugP4RNx2vaTZwD9iDDcTBhF3zrWz4hLoTsBCM1sEIOlCQtelbH/PTwJnmNlTAGa2tLCjj9wzhG5Wd1Wt3wZ4OnFfeXLxfwDnSrqN0Pr6RTN7PA6J+JdQH+ZZ4KB4MZhzrp2VvGEhb8vsSYRTWV9N7VpQYWZ/ZYiJMc3sWsKps1rbvgZ8bTjHzssS5mtT6txuicWVMFtqf2LTfldiMN1d+ctbd9q+LWE2Skudr67e09+mSI2lTHMHWsrUvWnTiw4loTVgiqTs2ZpZZpb9h3cL4MHM/cXAzlX7eAWApL8RnsiJZvbHpIDr50LgbElfIPRXhVApPYXQ/SC3nLl4CfC2GutXEC5Ay039RteK/NPZpnxXulb1pISC+tI+nynTivf3pX1nuxLn/u5embDv1Gl7V+SfP2nZ6DFJ+06ZnhbSfs+e780/DS/AE4n9t8d15//cjkn5sADdJE6JnqAveXLXG4csUWDLbF0aFvJ+gjclNAWXaTJh51y7y//D9riZ7TjCo40CXk4YV3sqcI2k15rZ0yPcbxG+QKiAnsOLeXs18GOgZv9f55wrTP5c3JSGhbyV2UviwRblLO+ccyNT7NWxDwFbZu5PZd0xshcD18eLTO+VdDehcjt0s0WdxesIjpJ0PGGEGYB/mtnyJoblnOsEabm4KQ0LeSuzVwCnSHo1cBvrzgte62pY55wbmeIqszcCL5e0DaESewBhmKus3wIHAj+VNIXQOlCqf+DNbLmkeyu3mx2Pc65DlLxhIW9l9r/j3y/V2GYU3VHOOecorp+WmfVKOgK4jJCvzjGzOySdBMw1szlx29skzSeMnfp5M3uimAhGTtLRwDGE03RIWkK4+Pb7ltLh3znnEhXYZ7YuDQu5KrNmyZfeOOfcyBVYRTOzSwhdprLrTsjcNkJl8ZjijloMSd8mzKh1KmGiAoA3AicAmxH61DrnXH2UvGEh/yWMzjnXaN7eWHEocKiZzc6su1LSXYQzZ16Zdc7VT8kbFnK1uCr49zgrznJJL4nrj4sD2zrnXKFk+ZcOMW+AdX7mzDlXN62Qi/MmwaOArxAmKsiOz/AQcETRQTnnHFD6KRQb6Hzg8BrrPw38rMGxOOc6Tclzcd5uBp8CPmlmf5D0n5n1/wBeXXxYzjmHdzN40RjgQ5LeDlwX1+0MbA78QtIPKwXN7MgmxOeca2clz8V5K7NbA7fXWL8aGFdcOM4596KUmfDa3LaExgMI+Rjgkbi8KlOu5D85zrlWVPZcnLcyuwjYAbi/av07WHsKMuecK0Zn9YcdlJnt0ewYnHMdqgVycd7K7GnA6ZLGE/rMvlHSRwhX0H68XsF1spSuJ6O60v5lGtOVME86MHZU/jmnrSftE28J42n0j0rrj2Pdif13uhKuo0kpC6DE8j5zdFDyBOpyMEMrE+atH5V/2HKVaHjd1Jar1O6FKfvX6sSdr8qfn1at7Ena9bKu+r1HK/vSBmR6dvXYpPKju/J/bkd3lydn99ej72p5vmo15R1n9qeSRgHfBMYTLjhYAhxpZr+qY3zOuU5W8gTaSJI2BXYFNqHq4l0z+1FTgnLOdYaS5+Lc/9aY2U+An8TZGLrMbGn9wnLOufKf2moUSQcBZxHOjD3F2j8tBnhl1jlXN2XPxcmTJpjZ4/UIxDnn3IC+AXwbOMnMEs7ZO+dc+8tVmZW0ISGZ7kXtU1zrFx+ac67jlbw1oIHWB871iqxzrilKnovztsyeDWxPmDRhCaV/Ws65ltcCV9A20C+AdwL/1exAnHMdpgVycd7K7F7A3mZ2fT2Dcc65tZQ8gTbQMcBvJe0F3EYY43sNMzupKVE55zpDyXNx3srsUmBZPQNxzrl1lDyBNtD/A2YCjwMvY90LwLwy65yrn5Ln4ryV2S8DJ0n6mJl5pdY5V3ei/Ke2GuirwOfM7HvNDsQ511laIRfnrcx+BZgGLJV0P+ue4tqu4Licc53Oyj+FYgN1A3OaHYRzrgO1QC7OW5mdXdconHOulpK3BjTQT4EP490JnHPNUPJcnHcGsK/XOxDnnFtHyRNoA40HDpX0dmAe654dO7IpUTnnOkPJc3HSpAmS9gSmE57WHWZ2dT2CKlRX/jmKpYT5jLvyz2WdGgeA5Z+enJ7EOaEnjlqZVH79MSvyFx6ddi6iL2Ga7/7EKT76RyW+Rylzwo9Om5+8qz/tdbHe/J8X6y9Rlkn8nA+l7P20GuhVwM3x9rZV28r9KplByuff8n9vrY55NTGUpLJA6IiYIuFdTj0lrL78wfSvTnuiq7rTXvTlXWm5NcXqvrRYUn5bR9X5PHx/wgem34rNw1D+XJx30oQtgIuB1xPGmQXYXNJc4D1mtmTABzvn3HCVPIE2ipnt0ewYnHMdrOS5OO+/WD8E+oCXmdmWZrYl8PK47of1Cs4518EsYclB0kxJd0laKOm4GtsPlvSYpFvicmgxT6QYkjaVdJKk2ZL+R9KJkjZpdlzOuTZXcC6uh7yV2b2Bw83s3soKM1sEHBm3DUnSWEk3SLpV0h2S1umHK2lrSX+WNE/S1ZKmxvV7ZH5gbpG0QtK7c8bunGtRsnzLkPuRuoEzgH0IXaUOlDS9RtFfmdmMuJxV6JMZAUm7AguBDwEvACuAg4CFkt6YuK88ubhmxT7m6H/EdXdI+tTIn51zruyKysVQn4aFlF6ItcJMqYevBPY0s2WSeoC/SrrUzK7LlDkNON/Mzov9c78FfMTMrgJmAEjakJDUL084tnOuFRX3n/5OwML4TziSLgT2A+YXdoT6Og24APiUmfUDSOoCzgS+A7wpYV95cjGEiv0RVeseBt5oZislTQRulzTHu5o51+YKysWZhoW9gcXAjTGHVOfiWvlnQHlbZv8M/JekLTMBbQV8P24bkgWVCRd64lL98kwHroy3ryL82FTbH7jUzJbnjN0516ISWgOmSJqbWQ6r2tUWwIOZ+4vjumrvi2eGZmfzXQnMAL5TqcgCxNvfBbZP2VHOXDzQY1eZWeUK0jHk/w1xzrWwAltm1zQsmNkqoNKwMCJ5E9GRwARgkaT748QJ/4zrcg8JI6lb0i2E6XGvMLPrq4rcCrw33n4PsJ6kjarKHEBooRjoGIdVftBWW8JV+M658snfT+txM9sxs8waxtH+F5gWJ4G5Ajhv5E+gMM8A29RYvw3wdOrOcuRiGKBiL2lLSfMI/xycUqtVNpuHV/W9kBqec65s8ufipjQs5KrMmtmDwA7AOwinu04D9jGzHcxscZ59xP30mdkMYCqwk6TXVBU5FthN0s3AbsBDhIvMAJC0GfBa4LJBjjGr8oPWo7F5Q3POlUzeloCcrQEPAdmEODWuW8PMnsi0Op5FGL2lLC4Ezpb0YUnbxOUgQpwD/nM/kBy5eMCKvZk9GNe/DPiYpE1r7H9NHh7dPS41POdciSTm4qY0LOTuM2tmFnd6xTACq97X05KuAmYCt2fWLyG2zMb+WO8zs6czD/0AcLGZrTVguHOuTRXXZ/ZG4OWStiFUYg8gXEy1hqTNzOzheHdfYEFhRx+5LxBGJj2HF/P2auDHwDoXUOQ1SC5+IlPsLODbNR67RNLtwL/is0Q6196Ky8W5GhYyd2vmn2q5+ztJerekayQ9Hpe/SHpPwuM3ljQ53h5H6Px7Z1WZKfGiBoDjCYk760CG0QrhnGtNRbXMmlkvcAThrM4C4Ndmdkcc6mrfWOzIeIX+rYTuUwfX51mli31VjwI2IPSfnQFsaGafjf3OcsuZizfL3F1TsZc0NT4GSRsAbwbuGsZTcs61kALPkq1pWJA0mtCwMGetYw2QfwaTd9KEzwHfBM4Hzo2r3wj8UtJXzey0HLvZDDgvXsnWRfgx+b2kk4C5ZjYH2B34liQDrgEOz8QwjVCb/788MTvn2kCB4xaa2SXAJVXrTsjcPp7wT3RpxQtfbxvhbvLk4iNjJb8XeJIXK/avAr4Tc7SA08xspPE458quoFxsZr2SKg0L3cA5lYYFhs4/A8rbzeBY4Agz+0lm3TmSbgBOIvShHeoJzKPGVbdVPyazGeB0lZndR+1OwgOShFKm0kspmzD1KUD/6LSLfvvG5C+7wZi0gR2mjFo2dKGMjcfmL98zLq0HSN+4/FMX9o1Jm6Kvf3Tae2QpU9SOSXiDSJ+5klUJn5e+tOmMqeP0t0nftzyaOAh3GUjah9CVYDsze7Zq2yTCRbOfNLPc3b9y5uKaFft4nO1yP4EXH5j8kDz6u9O+WX09iTkkabrtxG95alIofobSFyW8PdafOIVwf+JvX1/+8qt6C843VVKmhV1d5/leU2KpSyQlb1jI+6mZSBgqq9pVcZtzzhWr2AvAWtURwKnVFVkAM3sGOAU4utFBOec6SAvk4ryV2d8Sxnet9j6q+jo451xh8g8H0662A/40yPYrgdc1KBbnXKcqeS7O281gIXCcpD2Aa+O6XeLyXUnHVAqa2XeLDdE516navNU1j42B/kG2G1A9FrdzzhWq7Lk4b2X2YOAp4BVxqXgKOCRz3wgz0jjn3MiVPIE2wGJC6+w9A2zfjqphbZxzrnAlz8W5KrNmVmvmGeecq6uytwY0wB+A/5B0iZmtNZWWpPGEC3D/0JTInHMdo+y5OPekCc4511DG4CfYO8M3CNcr3C3pdF4cD/ZVhIvDRBg20Tnn6qMFcnHuymycIGEPYBOqLhwzsw8UHJdzrsOJ8rcG1JuZLZX0JsLwXN/kxQGajDBO4+Fm9miz4nPOtb9WyMV5J034DvAZ4G/Ao0DiwJbOOTcMJU+gjWBm9wPviDNuvYzw23KPmT3V3Miccx2j5Lk4b8vsx4D3m9nv6hmMc85lqU6D7bcCSduY2b2V+7HyeuMAZQVMNbMHGxWfc65zlD0X5x1ndjlVc3c751xd5R3XsNw5diSulXS2pDcOVEDSBpI+DcwH9mtcaM65jtECuThvy+zJwBck/T8z661nQM45V1H2flp1ti3wZeAPkvqBm4AlwApgA2A64UKwG4CjzeyyZgXqnGtvZc/FeSuzPwH+DXhI0t3A6uxGM9uz6MAKkzJX/Kj8gzvYqLQ5oftGJ85PPTb/J2eTMcuS9r15T1pXu4fHTMpddsL4lUn7fm7cuNxle8envYa949Peo57xY3KX7V45NmnfKHXe9oTn2pv4/2VfHbu8p3zf8ih5Aq0nM3sa+LykE4B3Am8GtgbGAY8D5wGXmdntTQsyr5TPf0LZ/p60nNDfk/Y9TCnf35O062SW8lQT002rMkt8PxPL9yWUr3eqSom9rz/te5FLyXNx3trbmYRE+kfCBWAlf1rOuXZQ9taARojjy86Oi3PONVzZc3HeyuwHgfeY2RX1DMY559ZS8gTqnHMdoeS5OG9b9GP4lInOuUay0BqQZ+kkksZJ2qLG+lc3Ix7nXJtrgVyctzL7NeAkSRPrGYxzzlUIUH++pVNI2h+4h3BR2DxJO2c2/6xJYTnn2lgr5OK83Qw+D0wDHpX0AOteALZdwXE55xyUfGzDJvgK8Hoze1TS64HzJH3TzH5Jx1z245xruJLn4ryVWb/wwDnXcJ3WhSCHnsr0tWZ2k6S3ABdLehml79XmnGtVZc/FuSqzZvb1egfinHNrae8JEYZrqaTtzGwegJk9KWlvwjBdfobMOVe8FsjFSYORSdpT0hGSDpe0e31Ccs65oMh+WpJmSrpL0kJJxw1S7n2STNKORT2PAn0EWJpdYWarzOxAYLfmhOSca3dl7zObqzIraQtJNwBXAF8EjgP+LOl6SZvXM0DnXAcraApFSd3AGcA+hJmzDpQ0vUa59YCjgOsLib9gZrbYzB4ZYNvfGh2Pc65DFDidbT0aFvL2mf0h0Ae8zMzujQd5CfDzuG3/nPtxzrncCuyntROw0MwWAUi6ENgPmF9V7j+AUwgXvZaGpHMG2GSE6W0XAr8ysyWNi8o51ymKysWZhoW9gcXAjZLmmNn8qnJJDQt5uxnsDRxeqcgCxB+FI+M255wrlhGuoM2zwBRJczPLYVV72wJ4MHN/cVy3hqQdgC3N7A/1fFrDtDHwXuDdwMvi8u647pXAF4C7JM1oTnjOubaVlouHsqZhwcxWAZWGhWqVhoUVeXaat2UWajcgl7tLsIRG5X+KGpV/XnkbnTYRd9+4tLmS+8blf2n/ZcwzSfvesueJpPKPjVkvd9nJ419I2vfTE9bPXbZ3fNprmFq+f3z+97Rr5dikfStlbvrU8qsSR2TqS5y3uz/ha96d/zuUR0JrwONmNuw+rpK6gO8CBw93H3X2N2AZ8AkzWw4gaTzwE+BW4B3A+cB3gL2aFWRtgoTPs3XXpyxAX1rapj+hfEpZSG/psoSvraUO0pZSvkSXtatEsaTqT3yTLKF8Stm8El7qKZLmZu7PMrNZmfu1Ghay42Wv1bAgKddZsrw1vT8D/yXpQDN7MB5sK+D7cZtzzhWvuN+qh4AtM/ensvashusBrwGujv9I/AswR9K+ZpZNzM1yFLBnpSILYGbLJX0D+LOZfVvSKcCfmhahc659lbxhIe//ekcCE4BFku6XdD/wz7juyJQDOudcHjJD/fmWHG4EXi5pG0mjgQOAOZWNZvaMmU0xs2lmNg24DihLRRZgIrBZjfX/ErcBPEva2TbnnBtSwbk4pWHhPmAXQsPCoBXkXJXZ2Bq7A+FU1mlx2cfMdjCzxXn2USGpW9LNkn5fY9vWkv4cp2m8WtLUzLatJF0uaYGk+ZKmpRzXOdd6ipoP3Mx6gSOAy4AFwK/N7A5JJ0nat77PohAXA2dLer+kaXF5P3A2cFEssxNwd94dDpGL3yLpH5J64xS62W2ei53rMEXlYurUsJD7v3gzM8LQXFfkfcwAjiL8mNTqLHkacL6ZnSdpT+BbhHEVIfQH+4aZXSFpItBBM7I716EK7BJnZpcAl1StO2GAsrsXd+RCfIpw6u3nvJi3e4FzgGPj/QXAJxP2OVgufoBwmu/YGts8FzvXaQrKxWbWK6nSsNANnFNpWADmmtmcwfdQ26Ats5L2kXSfpHWSnaRJcVvu0QxiS+s7gbMGKDIduDLevop4hVscD3KUmV0BYGbLsn3HnHPtqcDWgJZmZsvN7FPAhsD2cdnQzD5tZs/HMreY2S159jdULjaz++IsY/1Vj/Nc7FwHKjIXm9klZvYKM3upmX0jrjuhVkXWzHbP091rqG4GRwCnmtmzNQ7wDGHYhKNzRR98nzCEzED/yd9KGGoG4D3AepI2Al4BPC3ponha7NQ4Vtk6JB1WGZ5nleUa0cE5V0ZGGEkhz9IhzOx5M5sXl+dHsKvvM3guHkiuXLxWHu7zuq5zLa0FcvFQldntGPzq2CuB1+U5kKR3AUvN7KZBih0L7CbpZsLUjA8RJmsYBfxr3P4G4CUMcKWbmc0ysx3NbMfRShs+yTlXMgXOOtPqJG0a+/jOlvQ/kr4uadNh7CdPLh5Irly8Vh7uHj+MwzjnSqXkuXioyuzGDP6fuwEb5TzWrsC+8eq0C4E9Jf18rZ2ZLTGz95rZ9sCX47qnCeOQ3RIH2e0Ffku4IM0518a8m0EgaVfCLF8fAl4gDCT+YeAeSW9M3N2QuXgQnoud60Blz8VDVWYXE1pnB7Idaw+pMCAzO97Mpsar0w4ArjSzg7JlJE2JY4wBHE+4uAHC1W+TJW0c7+/JutNQOufaTXGzzrS604ALgFeY2UfM7COEU/4XEiZKyC1PLh6E52LnOlHJc/FQldk/AP8haVz1hjj7zEmxzLBVDY2zO2FKxruBTYFKx+A+wmmtP0u6jTBfyU9GclznXPmVvTWggWYA3zGzNWfK4u3vEi4GG7FsLpb0BkmLgfcD/y3pjnhMz8XOdaCy5+Khhub6BrA/cLek04E74/pXES4OE/DN1IOa2dXA1fH2CZn1s4HZAzzmCgZvJV6XgK6Ead0SpuJMn0YxrXz/uPzXZWzW83TSvjfvXplUfklP/ulyJ41OvOhuTF/uon1j0saD7x2b+B6Nzf/+d41Jm7uyK/E/ViWUTykLw+jWlJKhUr5vQ+mg/rA5PANsA9xVtX4b4Onh7nSQXHwjYTDzWo9Jy8UCuhPmYu3KX9YSp4iwxNmW+xP2n7rv1EaslOlsk6anBSzhO544M3fylLOp+0/RlRhLavl67ruvDlPU5tYCuXjQr6qZLZX0JuDHhEpr5dU0whhhh5vZo/UN0TnXiQSor+QZtHEuJEya8AXg73HdroQRZS5oWlTOubbXCrl4yP87zex+4B2SNgBeRnhe95jZU/UOzjnX2VJbndvYFwi59xxC3hawitDQcFwT43LOdYCy5+KUGcCeInT+d865+muBU1uNYmargKMkHQ+8NK7+p09Y4JyruxbIxYk9jpxzrlE6ZqSCmiQNOa2jYgdDM9t3iKLOOTdM5c/FXpl1zpVWh4xUMJAnmh2Ac85B+XOxV2adc+VV8taAejKzQ5odg3POAaXPxV6Zdc6Vk4Hyj1DnnHOuHlogF3tl1jlXXiVvDXDOuY5Q8lzslVnnXHmVO38651xnKHku9sqsc660yj62oXPOdYKy52KvzDrnysmAks8645xzba8FcnH7V2ZTJnpOKZswfziAdSfOqzyqL3fRyd1p46Zv3D0mqfyG3ctyl53YszJp3109+XuV9/ckzmXdk1ScvtH539NRY9ImYrfViRO3j8pfXt2J++7tTSufcn6pwInVhZW+NcDllJAvU3KldaV93izxq5JSPnXfyp/ig5SfnNSvYXFf2xr7TvsOK6F8StlhlU8qnaaVMlsr5OL2r8w651pXyROoc851hJLn4rTmReecaySzfEsOkmZKukvSQknH1dj+KUm3SbpF0l8lTS/8+TjnXCsqMBfXg1dmnXPlZEB/zmUIkrqBM4B9gOnAgTUqq780s9ea2Qzg28B3i3gazjnX0grMxVCfhgWvzDrnSktmuZYcdgIWmtkiM1sFXAjsly1gZs9m7k6gtbq1Oedc3RSVi+vVsOB9Zp1z5ZX/tNUUSXMz92eZ2azM/S2ABzP3FwM7V+9E0uHAMcBoYM+0YJ1zrk0V14VgTcMCgKRKw8L8Fw+V3rDglVnnXEkl9cF63Mx2HPERzc4AzpD0IeArwMdGuk/nnGtthfaHrUvDgnczcM6Vk1HkRQcPAVtm7k+N6wZyIfDuYcfunHPtIi0XT5E0N7McNqxDmp1hZi8FvkhoWBiUt8w658or/zDEQ7kReLmkbQiV2AOAD2ULSHq5md0T774TuAfnnHMpuXios2TDaVj48VAH9cqsc660ihqo28x6JR0BXAZ0A+eY2R2STgLmmtkc4AhJbwVWA0/hXQyccw4odDrbujQseGXWOVdOBvQV1zRrZpcAl1StOyFz+6jCDuacc+2iwFxcr4YFr8w650qquYNwO+ecg6JzcT0aFrwyO0yWOAe9pU7ynHBp3tiuVUm7HqOepPKjyT+JeJeKa0lruIT3KPX9r+ullv2Jr3krVRBbKVZXm4R1J3xfuvJ/WSzxe2VdiXk7Yf+psaSOYpzyG5L8e5NSXmmBp6ZKJew/8e2kKzH2eu67P/FNSnld6qLkudgrs8658ip5AnXOuY5Q8lzslVnnXDkZ0F/uBOqcc22vBXJxQyuzku4DngP6gN7q4RskbQCcA7wUWAF83Mxuz/NY51y7MbAW7rZScnFaybnAQ2b2rqpt3wP2iHfHA5uY2eS47RTCFcYA/2Fmv2pMxM655ih/Lm5Gy+weZvb4ANu+BNxiZu+RtC1h/t69cj7WOdduSn5qq8UdBSwA1q/eYGafrdyW9Blg+3j7ncAOwAxgDHC1pEurpp90zrWbkufiss0ANh24EsDM7gSmSdq0uSE555qicmorz+KSSJpKaF09K0fxA4EL4u3pwDVm1mtmzwPzgJn1idI5VwotkIsbXZk14HJJNw0wxdmtwHsBJO0EbE2YHSLPY4mPO6wyjdqq/hUFh++ca6jiprN1a/s+8AWGmNdH0tbANsRGBkKOnilpvKQphK4IW9Z43It5uPf5QgN3zjVByXNxo7sZvNnMHpK0CXCFpDvN7JrM9pOBH0i6BbgNuBnWjAs11GMBMLNZwCyAST0b+6+cc63MK6qFk/QuYKmZ3SRp9yGKHwDMNrM+ADO7XNIbgL8DjwHXwrpj962Vh8dv7m+ic62u5Lm4oS2zZvZQ/LsUuBjYqWr7s2Z2iJnNAD4KbAwsyvNY51ybMYO+vnyLS7ErsG+8qPZCYE9JPx+g7AG82MUAADP7hpnNMLO9CSOU3l3PYJ1zTdYCubhhlVlJEyStV7kNvA24varMZEmj491DCX2zns3zWOdcGyr5qa1WZGbHm9lUM5tGqKxeaWYHVZeLF+FuQGh9razrlrRRvL0dsB1weUMCd841T8lzcSO7GWwKXKwwHcgo4Jdm9kdJnwIwszOBVwHnKUx1cQfwicEe28DYnXPN4BXVhqmaGx1CRfdCs7XehB7gLzEXPwscZGa9jY3UOddwJc/FDavMmtki4HU11p+ZuX0t8Iq8j8154LqUVeIUol2pre8Ju+9LnEdxtaUF87yNHrpQtLw3f1mA/tX5Y1dv2vR/3avTvnxdq/K/6F2r015DJZfPXz+w1OlsU684TRlfMHkezUF35iMV1JmZXQ1cHW+fULXtxBrlVxBGNEiTMkVtHadtTZ5yNiWWxH0nz/ydMp1pPac+reP0tKm7r/cUr/Wc/ra1lD8X+wxgzrlyMrCSD9TtnHNtrwVysVdmnXPlVfLWAOec6wglz8VemXXOlVfJ+2k551xHKHku9sqsc66czCC1P7BzzrlitUAu9sqsc668St4a4JxzHaHkudgrs8650koeqcE551zhyp6LvTLrnCsnM+grdwJ1zrm21wK5uKHT2TrnXBLrz7fkIGmmpLskLZR0XI3tx0iaL2mepD9L2rrw5+Occ62owFxcD16Zdc6VkgHWb7mWoUjqBs4A9iEM+n+gpOrB/28GdjSz7YDZwLeLfUbOOdd6iszF9eKVWedcOZkV2RqwE7DQzBaZ2SrgQmC/tQ9nV5nZ8nj3OmBqoc/HOedaUbG5uC68z6xzrrQS/tOfImlu5v4sM5uVub8F8GDm/mJg50H29wng0rwHd865dtbMVtc8ZCUfbmEkJD0G3F+1egrweBPCqcVjqc1jqa0dY9nazDautUHSH+Nx8njczGYOtFHS/sBMMzs03v8IsLOZHVGj7EHAEcBuZrYy5/HdAAbIw9Cen+cieCy1eSy1FRHLgHkYis3F9dLWLbO13hxJc81sx2bEU81jqc1jqa3TYik4IT4EbJm5PzWuW4uktwJfxiuyhRnkn5WO+jzn5bHU5rHU1oK5uC68z6xzrhPcCLxc0jaSRgMHAHOyBSRtD/w3sK+ZLW1CjM4554bBK7POubZnZr2ErgOXAQuAX5vZHZJOkrRvLHYqMBH4H0m3SJozwO6cc86VSFt3MxjArKGLNIzHUpvHUpvHMgJmdglwSdW6EzK339rwoDpbmT5DHkttHkttHkvJtPUFYM4555xzrr15NwPnnHPOOdeyvDLrnHPOOedaVttWZnPMwz5G0q/i9uslTWvw8beO87/Pk3S1pKmZbadIuj0uHxxhHOdIWirp9gG2byDp4hjHDZJek9n2WUl3xDgukDR2hLFsKekqSfPjfo9qVjySxsb93xr3+fUaZWq+R5L2iBcIVZYVkt493FjiPrsl3Szp93njiNu2knS5pAXxdZ02kjjiPu+TdFt8bnNrbB/sPRr0sa6z5Mg/kvTDmCfnSdqhkcePZXaPn9c7JP1fXDdkfhhGLHny34fj63CbpL9Lel1m22RJsyXdGb/vb6xzLJMk/W/mNTgks63I36g8ufhgSY9lcm5lvOitJf0j8/59aiSxxH0OlovfEo/XqzB2dXZbPXLxYLF8L/N63C3p6cy2wt6flmFmbbcA3cA/gZcAo4FbgelVZf4dODPePgD4VYOP/z/Ax+LtPYGfxdvvBK4gXJw3gTCk0PojiOUtwA7A7QNsPxX4Wry9LfDneHsL4F5gXLz/a+DgEb4umwE7xNvrAXfXeF0aEg8gYGK83QNcD+yS5z2qKrMh8CQwfoSvzTHAL4Hf19g2YBzA1cDe8fbEkcYR93MfMGWQ7TXfozyP9aWzlhz55x2EmdYE7AJc3+DjTwbmA1vF+5vEv0Pmh2HEkif/vQnYIN7eJ/t6AOcBh8bbo4HJdY7lS8Ap8fbGMc+NpvjfqDy5+GDg9BqPHQ2Mibcnxvyz+Qjfp8Fy8TRgO+B8YP+qbfXIxQPGUlXuM8A58Xah70+rLO3aMjvkPOzx/nnx9mxgL0lq4PGnA1fG21dltk8HrjGzXjN7HpgHDHvAYjO7hpCEBrImDjO7E5gmadO4bRQwTtIoYDywZLhxxP0/bGb/iLefIwyRtEUz4rFgWbzbE5fqqyEHeo+y9gcuNbPlw40ltrS+EzhrgCI145A0HRhlZlcAmNmykcSRYLD3yLk1cuSf/YDz4/fxOmCypM0aePwPAReZ2QOx/NL4N09+SI1lyPxnZn83s6fi3esIk3sgaRKhYn52LLfKzJ6uZyyE57te/F2cSHgdeyn+N2rYr3V8HSqTm4xhhGebh8rFZnafmc0D+qseV3guzvG7kHUgcEG8Xej70yratTJbax726i/qmjIWxqB8Btiogce/FXhvvP0eQtLYKK6fKWm8pCnAHqw9c1HR1sQhaSdga2CqmT0EnAY8ADwMPGNmlxd10HgKZnvCf+FNiSeewrkFWApcYWYDxsLa71HWAbyYRIbr+8AXqEqQOeJ4BfC0pIviqahTJXWPMBYIPySXS7pJ0mGDxZN9j3I+1rmsPLmynl4BbKDQfecmSR+tbMiRH4ZtkPyX9QlCqzXANsBjwE/jd/0sSRPqHMvpwKsIjQa3AUeZWT91+I3K+Vq/L3bBmC1py8xjt5Q0j/A5OsXMRtLo8n0Gz8UDqUcuzhWLpK0Jn49Kg0ej6xCl0K6V2VZwLLCbpJuB3QhTa/bFCtolwN8JlaRrgb46xnEyoTXkFsKpipuBPkkbEFpNtgE2ByYozFk/YpImAr8BjjazZ5sVj5n1mdkMQkVsJ2X6fkY136PM89gMeC1hIP5hkfQuYKmZ3TRIsYHiGAX8a9z+BkK3loOHG0vGm81sB8JpzsMlvaVqe833KOdjnSuTUcDrCS1gbwe+KukVkCs/DMsQ+a9SZg9CZfaLmTh3AH5sZtsDzwPrXItRcCxvB24h5NsZwOmS1q/Hb1SO1/p/gWlmth3hFPp5mcc+GNe/DPjYcM8S5czFAyk0FyfGcgAw28z6AJpQhyiFdq3M5pmHfU2ZeNp6EvBEo45vZkvM7L0xMX05rns6/v2Gmc0ws70J/YnuLiiudZjZs2Z2SEwkHyX0jVoEvBW418weM7PVwEWE/lwjIqmHkDx/YWYXNTueeMynCafvZ1atH/A9ij4AXBzjGa5dgX0l3UfojrKnpJ/njGMxcEvsztIL/JbwgzcisRW8csr1YkK3mez2gd6jIR/rXJU8ubqeFgOXmdnzZvY4cA3wumyBgfLDcAyV/2KZ7Qinlvczs8pv0mJgcabFcjYj/K7niOUQQhcMM7OFhGsWtoX6/UYNkoufyHQnOIvwD0j1Y5cAtxMqlcMxZC4eRNG5OCWWdc4ONrIOURbtWpkdch72eP9j8fb+wJVmVtQMEnnmgZ8iqfL6Hw+cE9d3V05lx6S2HVDY6f1qClfIjo53DyX0tXmWcDp/l3iqQsBehH5VIzmWCH2+FpjZd5sZj6SNJU2Ot3FxMSwAAQAASURBVMcBewN3VpWp+R5lZPspDYuZHW9mU81sGuFzcqWZrdXiPEgcNxJaSDeO9/ckXMwybJImSFqvcht4G+EHIlum5nuU57HOVZkDfFTBLoTuQw838Pi/A94saZSk8cDOwII8+SFVzvy3FeEf9Y+Y2ZoKiJk9Ajwo6ZVx1V6M4LueJxZCzt0rlt8UeCWwqOjfqJy5ONuPel9i7pc0NT6GePbuzcBdw4kjTy4eRKG5OG8skrYFNiC0vlbWNbQOURpWgqvQ6rEQrpK9mzCqwJfjupOAfePtsYSrxBcCNwAvafDx9wfuiWXO4sUrMscSvgTzCRcAzBhhHBcQ+piuJvz3+AngU8Cn4vY3xhjuIiTRDTKP/TohqdwO/KwS4whieTOhT+U8wumrW+Lr1PB4CF/wm2MstwMn5H2P4rZphBakrgI/M7sTr1pNiGPv+BxuA84FRo8whpcQ+lzdCtyR+ewO+R4N9FhfOnfJkX8EnEHIk7cBOzby+LHM5wn59nbC6fYB88MIY8mT/84Cnspsn5t5/Axgbnz8b7O5sU6xbE6oBN0WX4OD4vqif6Py5OJvxZxyK6Hldtu4vpL/bo1/Dyvoc7M7tXPxG+Ln6HnCmdw7Mo8pNBcPFUu8fyJwclX5Qt+fVll8OlvnnHPOOdey2rWbgXPOOeec6wBemXXOOeeccy3LK7POOeecc65leWXWOeecc861LK/MOuecc865luWVWedGSNJ9ko5tdhzOOedcJ/LKbElJ2lTSDyT9U9JKSQ9JulTSO5odW5lImibJJO2Yo+yXJf1N0vOSfEw655xzrg14ZbaEJE0D/kGYG/t4wqDSbwX+AJzZvMha3hjCIP/fb3IczrkSknSupN83+JgbSHpU0ksbeVxXH5L+R9Lnmh1Hp/HKbDn9KP7d0cx+bWZ3mdkCMzudULEFwtSHki6W9FxcLpI0NbP9REm3S/pYPBX+vKSfShot6d8lPSjpCUnfzUyXWjltfqKkn0taJumR6tPoCcc+ILYuPyfpt5KmVO3nEEnzJa2QdLekz1bFYpIOiwnieUmLJGWn9bs3/r0xlr16oBfVzE4ws+8QZpvJRdLVks6MreRPxeXUbIzRWEn/LelZSYslfb5qP8dImhefw0OSzqpM4Ri3T5L0M0lL42uxSNLRVdtnxe3PSfq/PK3RzrnS+xJwiZn9s7LCz8zlF3P06YNsf4ukOfE1NEkHD1J2Y0k/ir+BK+M/GX+WtHemzLlxP9XLjFjkJODLkiYV9Rzd0LwyWzKSNgRmAmeY2bLq7Wb2dCzXRZhXfFNgj7hsDvxWkjIPmQbsB7wLeC/wfsJ86G8A3gYcCnwGeE/VoY4hzH+9A/A14JuS3juMY38w7vttwPbANzLP9ZPAN4ETgFcBnwO+CPx7VSwnxOO9DvgVcI7CHOYAO8W/M4HN4nMs2ocJ35U3Av8POAw4uqrMZwnTGO4AnAJ8W9IbM9v742NeDXwoxv1fme3/CbyW8D69Evg4YbrcyjzqfwC2iNu3B64BrtTac5Y751qIpPGEHHx2Zt00/MxckSYSpsk9CnhhiLK/IeTmTwCvIOTbS4GNqsr9ifB7k11uBzCz24BFwEG4xmn2fLq+rL0QvkgGvGeIcnsDfcC0zLqXECpNb433TyR8eSdlyswGHiMzbzRwNXB65v59wBVVxzsL+GvisVdUHfvLwMLM/QeAj1Qd52hgfua+Ad/K3B8FLOfFecKnxTK553QH9g8f/VxlrwbuhjD1c1z3FWBx1et1QdXj7gG+Msh+ZwIrga54fw5wzgBl9wSWAeOq1t8CfKHZn1lffGmXBTgX+H28PYbQJenRmMuuA95cVX4CcH78fj5KqHz+Hjg35/H2B56syi+XEP6RnVij/OTM7UHji7nrx8B34jEeI1ToxgBnAE8PkIOvJlSafwA8FZdTK7kq4bW5mnCW8ZvA48BS4LRMzhPwBeCfhN+p2yp5PWEf5xLyf3aZNsjrvQw4eIBtk+Pj35r3MzJImROIv5e+NGbxltny0dBFgNCSucTM7qusMLNFwBJgeqbcA2b2TOb+o8DdZraqat0mVfu/tsb9yn7zHvv+qmMvqRxH0sbAlsB/x64MyyQtA04GqvuOzcscp5eQlKvjrafrLGao6FpgC0nrZ9bNq3rMmucKIGlPSVfELgjPEfrujgb+JRb5MfBBSbdKOk3Sbpl9vR4YDzxW9Vq9hnVfK+dcMb5NOLP0ccLZkNuAP1adDfkOsBvh7NOehLNH/5pwjH8Fbqrkl7xn5hLi+zDwHLAzIbd+H/gt4R/0HYHzgLNqnOEZ6mxUnmNX9tMLvAk4Iu7jg3HbfxJaQA8n/G58i/B78M6EfRxFyMc/5cUW0gcZnmVx2VfS2GHuo+IGYCdJ40a4H5eTV2bL5x7Cf4evGsE+shWv1TW21VpX1GdhqGNXjlP5+ylgRmZ5DeFUfFY94y3KgDFK2ppwinABoZvH6wk/AhAqtJjZpcDWhFaHKcAfJP00luki/MMxo2rZFvhq8U/Fuc4maQLwaeCLZvYHM1tAyFWPEipfSJpI+B5/0cyuMLM7CJWz/sx+tox9OufHPvPvrzrU1oR/fCteRmjQWDDS+KI7zOxEM7sH+C6hdXO1mf3AzBYS+ncK2LXqEA8DR5rZnWb2a0LL7DGJx4Zwlu0EM7s77ucqYK+4j2OAQ83sj2Z2r5n9EvhJ3n0AxMaSVcByM3skLn2DvXYDiQ0lBxO6Bzwt6drYsLBzjeIzsw0Lki6t2r4E6CF0v3MNULYKQcczsyeBy4AjYrJcS+aioQXA5rF/VWXbSwhfnvkFhLJLjfuVBDviY5vZo4Qv/EvNbGH1khBnpYW5O+ExqXau6gu8C6Fl+tmcj9+RUGn9rJlda2Z3UyPJmdnjZvYzMzuY8KP4MUljCP3nNgX6a7xWS0fyxJxzNb2UUBn5W2VFrCRlz1BVytyQKfM8se9k1AscbWbTCdcNfD9W5CrGEU7TV+Q9M5cnPlj7rJYRTtPfllm3mtCNoPpM12Bno/Iee63jR5UzVtOBsYTW3OzZpk8zyJm5qn0Uzsx+Q8jN/0boK/sm4DpJX6oqeg1rNywcWrW90jfXW2YbZFSzA3A1HU5IFHMlfZXwZRbhQqvjga0IHdDnAb+QdFR83H8RKj5XFhDDLpKOJ/Sx3R34KOF0DwUe+2vAf0l6mtBPrIdwAdUWZvatnPtYSkgcb5d0H7CiqmvDGvGisQ0J/WzJXH26sNYpvYzNCT9CPyJcpPV5wimyvO4h/ON4tKSLCJXho6tiO4nw+t1B+F6+F1hkZisl/YnwefidpC8AdxK6J8wE/mRmf0mIxTk3MrnHqDazhwmtnJjZI5IeJ+Sg52ORx4ENMg/Jnpm7uID4mnlmbqDjd2WO92+EfruDPaahZ+bMbAVwRVxOknQWcKKk0zLd85YP0eiyYfz7WL3idGvzltkSiv1PdyB8mU4hVByvBPYl9F2q/Je9H+HLclVcHgHeXfUf9XB9l3AV7c2EitsJZja7yGOb2VmE03QfAW4F/hKf372DPa5qH73AkYT/jJcQRj0YyEnx+Zwa798cl6GGuPoFoeX3esJpsLOB7yXEOI/Qt+sYQsv1oUD1jGErCSM93EqouK5HSPSV1/sdhM/AT4C7gF8TRj1YgnOuaP8knPVZc/pdUjehD+n8TJnVhJFhKmXGE7pKrUPS64FuM8v26byZTGtmwpm5PPGNxGBno4o49nxCztu6xtmm+xNjXUV9z8zNJzQwpPSjfQ3wUDwD6Rqh6CvKfGn9hXB1/rHNjqMMC1UjPfjiiy/tu7D2aAbfJ7SqvoPQUjqLcIHQZpnyZ8Z8uRehUvpL4Bngp1X73ZBw1uVNVetfSxgZZqPMupfE495J6GP/SkL/+E8TLuglT3y1chehC8SJVeseAY7I3L+acNHYD+Kx9yeMfHBs3mMPcvzs6/ufwBOEBo2XEU7Xfwo4LO8+4v1ZwE2EM25TyIy6ELdP5MXuAMsJIw3MALaqKrcRocHgIEJDzjbx9X+EzOg+1ccf5HN0drM/z520eDcD55xzbl1fjH9/Shi26WZgpoWuAxXHEobnmkOozH2P0L99TT/Y2O/9t8DJZvb37AHM7DZJNwAHEIbLwswWSdqBMJnCKYTxpZ8gnLU5LDG+4cqejTLWPRtVxLG/Srho7FjCaC7PEoYb/HZirKcRRmWYT+ijug3hH4yKHQlnDyu+HpfzCBd8VSwjDDF2FKFyPYYwRNovSehWFkdCeA9hnGDXIIr/RTi3Rux7erqZndbsWJpNYUax283siGbH4pwrt1hxvR841cy+E0/V/xK4y8xOHOAxMwmtoNNtmFfiF8lz3shIOhzYz8ze1uxYOom3zLp1mNm0ZsdQFma2e7NjcM6Vk6TtCafZbyD0c/9i/PurWGRXwpio8yS9O677iIVZogAwsz9KOgOYSqgIu9a2mjCrpmsgr8w655xzw3cMoW9pL+E0+VvMbDGAmf2VHBdam9kP6xmgaxwzm9XsGDqRdzNwzjnnnHMty4fmcs4555xzLcsrs84555xzrmV5ZdY555xzzrUsr8w655xzzrmW5ZVZ55xzzjnXsrwy65xzzjnnWpZXZp1zzjnnXMvyyqxzzjnnnGtZXpl1zjnnnHMtyyuzzjnnnHOuZXll1jnnnHPOtSyvzDrnnHPOuZbllVnnXEeQdI6kpZJuH2C7JP1Q0kJJ8yTt0OgYnXOundUrD3tl1jnXKc4FZg6yfR/g5XE5DPhxA2JyzrlOci51yMNemXXOdQQzuwZ4cpAi+wHnW3AdMFnSZo2Jzjnn2l+98vCoogIso9EaY2OZUJ+dK7F4V+L/DT09uYv2jUt7G3vHp4XC2L7cRUd35y8LaS9jr6W9hr2ru5PKd63IH82o5y1x36uSyltvwutoabGUyXM89biZbVxr29v3mGBPPJnvdbhp3so7gBWZVbPMbFZiOFsAD2buL47rHk7cj8sY3T3exvWsn/8BKZ/n/v60YPrSyhsJsdT7a5iQLKXE35uU36dRaXnVRqXF0t+Tv3x//p/JUD6xxmMp5bvTPltdXWkfGCl/eSXWT5bf88iAeRganouHlYfbujI7lgnsrL3qsm+NSnvpusYn1iA32yR30WdeNyVp14/tkPZJH/Wy53KX3WKDZ5L23dOVv9L21IpxSft+9NHJSeXH3TUmd9l/uX5l0r7Hzl+cVL7viadyl7Xe1Un7LlPl9082+/6Btj3xZB83XLZVrv10b3bPCjPbsbDAXGHG9azPG7f+WO7yWpX/82zPL0+KxZY9n1a+t7cuZYHkGoe681ciNSZ/LgPQxIRGn8kJ/5gAqzeemFR++Wb5Y1++aVrF+oUBq2u1rdoo/++TJqU1WIwdn1h+dP7vxehRaY1KN8w8ZcA8DK2Ri9u6Muuca10G9JPY8jYyDwFbZu5Pjeucc65jNTgXDysPl6LPrKSZku6KV68dV2P7GEm/ituvlzStCWE65xrIMFZbX66lIHOAj8araXcBnjGzjupi4CM+OOeqNTgXDysPN71lVlI3cAawN6FvxI2S5pjZ/EyxTwBPmdnLJB0AnAJ8sPHROucaqcjWAEkXALsDUyQtBr4G9ACY2ZnAJcA7gIXAcuCQwg7eOs4FTgfOH2B79krjnQlXGu/ckMicc01TVC6uVx5uemUW2AlYaGaLACRdSLiaLVuZ3Q84Md6eDZwuSWYl6vznnCuUYfQV+BU3swOH2G7A4YUdsAWZ2TVDnPlac6UxcJ2kyZI267QWbOc6SZG5uF55uAzdDAa6cq1mGTPrBZ4BNqq1M0mHSZorae5q0i7Scc6VSz+Wa3ENkydfr5WHV/W90LDgnHP1UfZcXIaW2ULFISBmAayvDf1XzrkWZUCfV1RbUjYPTxr7L/4mOtfCWiEXl6Eym+fKtUqZxZJGAZOAJxoTnnOuWbzVtXR8xAfnOlDZc3EZuhncCLxc0jaSRgMHEK5my5oDVAYq3B+40vvLOtfeDOgzy7W4hun4ER+c6zStkIub3jJrZr2SjgAuA7qBc8zsDkknAXPNbA5wNvAzSQsJ06Ad0LyInXON0tBRZp2P+OCcq6nsubjplVkAM7uEkCSz607I3F4BvL/RcTnnmsew0vfTajc+4oNzrlor5OJSVGZLI3VC4xQJUxEC2Nj8k06vmJwW9+opadOfvmTD/FOrbjvp0aR9j+nKPwXk0pXrJe3bLO11WfpczQEyanp+87RJwccsTpvSUc8ty13W+lIHqk78H7tZp44M+sqdP10eEnQl9GirZx6up1aNG1BC7MlfydTXJSWWxI6S1p0WvY3KX74rcd+jutPycMoUtWNHJU6tPJQWyMVemXXOlZIhVtO6FQTnnGsHrZCLvTLrnCslA/pL3hrgnHPtrhVysVdmnXOl1Vfy1gDnnOsEZc/FXpl1zpVSGKi73AnUOefaXSvkYq/MOudKqz/xIj7nnHPFK3su9sqsc66UWqE1wDnn2l0r5GKvzDrnSskQfaWYpNA55zpXK+Rir8w650qr7Ke2nHOuE5Q9F3tl1jlXSq1wass559pdK+Rir8w650pK9KVO8eOcc65g5c/F7V+ZTZlKTylTLia+sV1p/9X0j8n/1qyalLbviRstTyr/ug0eyl321eMWJ+17tPJP0ffY6PWT9t2VOPHi08vG5S77/OZpU+tO2nBCUvnuJ8bkLqtVadMTW+rst6nT36YY5C0yYDVp00C7EpKwnvz5TKsLnoozK2VaXVdb4m9ZalfLlDqTJaYHS63xJExROyphulmAMT1pn/PxPfnz/LhRab8JQ2mFXNz+lVnnXEsyK39rgHPOtbtWyMXljs4519H6Ua4lD0kzJd0laaGk42ps31rSnyXNk3S1pKmFPyHnnGtBRebievDKrHOulMJFB125lqFI6gbOAPYBpgMHSppeVew04Hwz2w44CfhWsc/IOedaT5G5uF68m4FzrqQKPbW1E7DQzBYBSLoQ2A+YnykzHTgm3r4K+G1RB3fOudbl3Qycc25YDOinK9cCTJE0N7McVrW7LYAHM/cXx3VZtwLvjbffA6wnaaM6PDXnnGsZibm4Kbxl1jlXWn35B+p+3Mx2HOHhjgVOl3QwcA3wEJA89oNzzrWbhFzcFF6Zdc6VUsFTKD4EbJm5PzWue/F4ZkuILbOSJgLvM7OniwrAOedakU9n65xzI9BfXD+tG4GXS9qGUIk9APhQtoCkKcCTZtYPHA+cU9TBnXOulRWYi+ui3NE55zpWkVfQmlkvcARwGbAA+LWZ3SHpJEn7xmK7A3dJuhvYFPhGXZ6Yc861EB/NwDnnhskQq1On+Blsf2aXAJdUrTshc3s2MLuwAzrnXBsoOhfXg1dmnXOlZEbph4Nxzrl21wq5uP0rs8r/BihlzunU+amVVt5G5Y+7d0JaKFut/2xS+VePW5y77Iyx+csCdJN/7utHRqXFvSJxIu5FG+QfhWnxlIlJ+165wZik8hPGjs1dVi+sSNo31p9YvFlJrLkzyrgCJeQz6074vCXk947Slfi6pPw+pf6WJf5WptSZUutXyRfkd+X/fepKKAvQ0502UEpPV/7yY7tXJ+17aOXPxe1fmXXOtSSj/K0BzjnX7lohF3tl1jlXWmUfDsY55zpB2XNxQ6OTNFPSXZIWSjquxvatJf1Z0jxJV0uamtl2iqTb4/LBRsbtnGs8Q/RbvsXlJ+kcSUsl3T5Imd0l3SLpDkn/F9eNlXSDpFvj+q83LmrnXLO0Qi5uWGVWUjdwBrAPYQ70AyVNryp2GnC+mW0HnAR8Kz72ncAOwAxgZ+BYSes3KHTnXJOUfTiYFnUuMHOgjZImAz8C9jWzVwPvj5tWAnua2esIuXimpF3qGqlzrhTKnosbeeSdgIVmtsjMVgEXAvtVlZkOXBlvX5XZPh24xsx6zex5YB6DJGPnXOszwkDdeRaXn5ldAzw5SJEPAReZ2QOx/NL418xsWSzTE5e0q16ccy2nFXJxI4+8BfBg5v7iuC7rVuJ0ksB7gPUkbRTXz5Q0Ps7SswdrT025hqTDJM2VNHc1Kwt9As65RhJ9ORdXqFcAG8SuXjdJ+mhlg6RuSbcAS4ErzOz6WjvI5uFVvcsbE7Vzrk7Kn4vLdgHYscDpkg4GriFMO9lnZpdLegPwd+Ax4Fqg5jgVZjYLmAWwvjb0VgPnWlSlNcA13Cjg9cBewDjgWknXmdndZtYHzIhdES6W9BozW6fvbTYPTxq/uedh51pYK+TiRlZmH2Lt1tSpcd0aZraE2DIraSLwPjN7Om77BnF6SUm/BO6uf8jOuWYxK/+sM40kaQywOaGC+ZiZPVanQy0Gnohdup6XdA3wOjI518yelnQVobvXgBeSOedaXyvk4kZWtW8EXi5pG0mjgQOAOdkCkqZIa0bBPh44J67vjt0NkLQdsB1wecMid841RZ915VralaT1JH06ViifARYSKo+PSHpA0k/iWasi/Q54s6RRksYTLrpdIGnj2CKLpHHA3sCdBR/bOVdCZc/FDWuZNbNeSUcAlwHdwDlmdoekk4C5ZjYH2B34liQjdDM4PD68B/iLwswjzwIHmVlvo2J3zjWeQelnnaknSccAXwYWEf7x/wawBHgB2BB4DfCvwBWSrgM+Y2b35NjvBYRcO0XSYuBrhByLmZ1pZgsk/ZFwoW0/cJaZ3R4bEs6LI9N0Ab82s98X+Zydc+XTCrm4oX1mzewS4JKqdSdkbs8GZtd43ArCiAbOuY6htm51zWEXYLdafVKjG4BzJH0K+ASwGzBkZdbMDsxR5lTg1Kp184Dth3qsc67dFJuLJc0EfkBo2DzLzE6u2r4VcB4wOZY5LtYfB1S2C8CKJVDKvNAJ83wrcX7q5DnEE/bfNzrt+oqNxy0bulDGS0cvzV1261H1u9aji+eSyj/S83RS+U3H59//feunzau9av20/kYTxozOX7g7sS9TYnnVvtayGIPsOlx0UO7WgHoysw/kLLeSMC5se0jJrSn53bWf1J+b1PL9+T9flpir+vrT6gQplcne/mL7txaZizNzDuxN6J9/o6Q5ZjY/U+wrhDM/P47zEVwCTBtsv7lfHUmbSjpW0o/j8FhI2lXSNonPxTnncin7QN31Jmm7zHUEzjnXFAXm4jxzDhhQmRhrEqF71aByHVnS64G7gA8TTmdVDrI3cYQB55wrUitModgANwNTKnck/UHSZk2MxznXYRJz8ZTKGNNxOaxqd3nmHDgROCj26b8E+MxQMebtZnAa8AMz+5qk7LnYy4BDcu7DOeeS9Ldxq2tO1TX1txCG5nLOuYZJyMWPm9mOIzzcgcC5ZvYdSW8EfhbHtO4f6AF5K7OvJ7TIVnsY2DQ9TuecG5wZ9LV3q6tzzpVewbl4yDkHCPXNmeHYdq2ksYQzVANewJO3qv0CsEGN9dsOtnPnnBsJ72aAse5lKz6jlnOuoQrMxUPOOQA8QJiBEEmvAsYSZn8dUN6W2d8BX5P0/njfJE0DTgF+k3MfzjmXm1HsrDP1GA6mAQT8XNLKeH8s8BNJy7OFzGzfhkfmnOsIRebinHMOfI6Q5z5L+Of9YDMb9J/4vJXZYwmdcB8DxgN/JXQv+BthCAXnnCtUKwwH0wDnVd3/eVOicM51rKKHScwx58B8YNeUfeaqzJrZs4TpDfcEdiB0T/iHmf0p5WDOOZef6C9uoO41w8EASKoMB5OtzCYPB1NvZuYX2DrnmqzQXFwXSZMmmNmVwJUAknrqEpFzzkUFTqFYaziYnavKnAhcLukzwATgrUUdvGiSRgFjzSxtBhTnnBuGsk9nm3ec2SMlvS9z/2zgBUl3SXpl3aJzznWsyhW0eRaGHtswj8pwMFOBdxCGg2lqc4SkvSR9oGrdccAy4GlJf5Q0uSnBOec6QmIuboq8LbNHAh8HkPQW4APAh4D3Ad8B3lWX6EZM6dPI5tWVuN+Bh0cboHz9Llge1706qfyGXStyl53UNT41nNye60prhJrQtXLoQhlJr0tP2vvZOzat87yNyX/iQ6MSZ6Venfb+WxPrcwmntoYa27Auw8E0wHHApZU7knYCvgmcDSwAPg98Of4trzrms9Ko83O0/vz7V38df28Sn6cS4gZQwuzZKWUBulJn5u5LmFY+oSzA6r60vNqbMP3tqoKns4WkXNwUeaPbArg33v434H/M7NeE03K71CEu51yHK3gGsLoMB9MArwX+L3P//cDfzeyTZvZdQkODj2TgnKubVpiNMW9l9llgk3h7b+DP8fZqQsJ3zrnC9aNcy1DMrBeoDAezgDBqwR2STpJUqQx+DvikpFuBC8gxHEwDTGbtluFdgT9m7t/IulNBOudcoYrKxfWS9/zk5YQxv/4BvIwXT3u9mhdbbJ1zrjCtMBxMAzwMvBR4UNIYYHvgq5nt6wFp/Wmccy5B0bm4HvJWZg8HvgFsBexvZk/G9TsQWjCcc65wZe+n1QCXAt+OF33tCzwP/CWzfTtgYTMCc851jrLn4pRxZj9TY/3XCo/IOecAM9Fb8gTaACcAFwF/Ioxg8DEzW5XZ/nHgimYE5pzrDK2QixMvgwZJ/wKMzq4zswcKi8g556Kyn9qqNzN7HHiLpEnAMjOrvh77/YRKrnPO1U3Zc3GuymxMpD8kDMk1ukaR4seBcM51tFbop9UoZvbMAOufrLXeOeeK0gq5OG+78WnA64B3AysIY8x+njCLzgfrEplzruOVfTgY55zrBGXPxXm7GewDHGhmf5HUB9xkZr+S9DDw/4DZdYvQOdeRKmMbOueca55WyMV5W2YnA/fH288AG8Xb1wJvKjgm55wDyj+2YSNImizpnZLeJElV2yZIOmGgxzrnXBHKnovzVmb/Cbwk3l4AHBCT6nsB77PlnCuelf/UVr1JejUh5/4O+Ctwo6StM0UmAj6qjHOuflogF+ftZnAuYTzDq4GTgd8TZtPpAo6qR2BN0VWeH8WuVfknke5emRZ36hAbZWn5SpxtnFWWdl3iyr6EwT36016T5FFNuhIe0J2485R9Q9pc7InzsA96WMp/0UEDfItwBuwjwPrAD4C/SdrDzO5pamQ5mcASPnNVjc+FlYXwmeoIiRPXJU1015eYiROLKyGUlLJlk1rd6Ep4sqO6Un8tB9cKuTjvOLPfy9y+UtK2wI7APWZ2W72Cc851trIn0AbYBdjDzJ4nTJjwAUnfBa6WtAeh25dzztVV2XNx8jizsGZcWR9b1jlXN61w0UEDjKGqQdHMjondvK4mjCzjnHN10wq5OHdlVtLOwF7AJlT1tTWzI3M8/hzgXcBSM3tNje0bAOcQ5iFfAXzczG6P2z4LHEpI6rcBh5jZiryxO+dak5U8gTbAXYSzYPOzK83ss5K6CH1pk0jaEjgf2JSQU2eZ2Q+qynwY+CIg4Dng02Z2a9w2GTgLeE18/MfN7NrUOJxzraPsuThXRyZJxxL6bR0MzABem1nWqZgO4Fxg5iDbvwTcYmbbAR8l9A1D0hbAkcCOsRLcDRyQ85jOuRZlFvp351na2MXAgbU2mNlRwM8huVN7L/A5M5tO6MZwuKTpVWXuBXYzs9cC/wHMymz7AfBHM9uWMP74gsTjO+daSCvk4rwts0cBR5rZ6cM9kJldI2naIEWmEy4uw8zulDRN0qaZOMdJWg2MB5YMNw7nXOsoe2tAvZnZtwgXgQ20/XDg8MR9Pgw8HG8/J2kBsAWZ1l8z+3vmIdcBU2HNbJBvITRsYGargFUpx3fOtZ6y5+K81ej1gUvqGQhwK2GoLyTtBGwNTDWzhwgzkD1ASMDPmNnlA+1E0mGS5kqau9p7IjjXwvINBVP2vlxlFhsYtgeuH6TYJ4BL4+1tgMeAn0q6WdJZkibU2O+Lebh3edFhO+caqvy5OG9l9gIG7yJQhJOByZJuAT4D3Az0xb60+xGS6ObABEkHDbQTM5tlZjua2Y49GlvnkJ1z9WSmXItLJ2ki8BvgaDN7doAyexAqs1+Mq0YBOwA/NrPtCSMsHFf9uLXy8KjxdYnfOdc4Zc/FA3YzkHRM5u6DwNcl7QrMA1Zny5rZd0caSEymh8Rji9BnaxHwduBeM3ssbruIMOvYz0d6TOdcebXC2IaNImkr4EGrGhA05sot4wgzKfvrIVRkf2FmFw1QZjvChV77mNkTcfViYLGZVVpyZ1OjMuucax+tkIsH6zP7mar7ywiVyOrpaw0YcWU2XiG7PPbBOhS4xsyelfQAsIuk8cALhBEV5o70eM65krPksd/b2b3AZsDSqvUbxm25ZwiJFeCzgQUDNUTEyvNFwEfM7O7KejN7RNKDkl5pZncR8vH8WvtwzrWJFsjFA1ZmzWybIg8k6QJgd2CKpMWEKRh74rHOBF4FnCfJgDsIp7Yws+slzQb+QbgK92bWvrLWOdemyjL7XAmI2hNYTSQMZZhiV8KMYrfFbl0QRpPZCtbk4xOAjYAfxVm2es3s/7N353GSVeX9xz/fXmZjhwECDDKoIIyKgIggKpsoLoG4g6JCRKI/EJQgkRhRMagIEjUQDSKKKxoChigKRCAYRWUQGPZFFhlANhm2YWZ6eX5/nNszNUV19z3dVdW3ur7v1+u+uureU/c+tT11+txzz9mpKPth4PuSZpDOnh2SeXwz6zBVz8XZkyYU/ayIiKdyHhcRDYeXqdl+JbD1KNs+hecfN+sqQfWvoG01SV8tbgbweUm1V1P1AjsD1+bsMyL+j3GG84qIQ0lnyBptu5Y09q2ZdYFOyMU5kyZ8BDiaNIQLku4ndS/4cn0/rkrJnQC5VTJfIq0YLF227+m8UB58Zq2s8g8PPeti5VE9NpT1P06Wvwz1Z5V/cGDdrPKPLiv/PLU8bzy9nvJvJwCRNT995th+mfPZZ2nq9625V8dK2pc0RmovcGZEfKFu+78AexZ35wAbRcS6TQtgYl5c/BXp7FXtMFgrSGesTml3UFkkYmbpXhCwIqNsb0bZiZTP+W7lfq8q/LM5psznGb155XPS/NCMrF1nl2fmUOmis2YNjF+oxpozl2eVX2fGMxllmz2SU/VHjSlVmZX0ReAw4GTS5AkAu5JORW0CHNuS6MysqzXr915SL3A6sA/pIqarJF0QEbVjq360pvyHSUNWTamI2BNA0reAo0YbdcDMrJWq/r9X2ZbZQ4FDI+LcmnWXSroV+HdcmTWzJouA4eGmzSizM3BHRNwJIOkc0pB/o128dCAV6toUEe6XamZTosm5uCVy+swuGmVdtZ+hmXWsjFNbcyXVjnJyRkTUXii6GWmIwRGLgZc32pGkLUjjWl+aEWrLSXonafSAjajLuxGx35QEZWZdYVp0MwC+Q5oy8ai69R8CvtvUiMzMChmnth6pudp+sg4Azo2I8h3mWkzSycBHgMtI03lX/KSfmU0n06WbwUzgXZJeR5qnG1KrxqakIVpGrrglIo5sbohm1q2aeAXtfcDmNffnFesaOYD0z3uVvBc4sK6rl5lZW0yX0Qy2IV01C7BF8ffPxbJtTbmK193NrFMETZ0e8SpgK0lbkiqxBwDvqi8kaRtgPVZd6FoVPWQOwWVm1gxNzsUtUaoyO3JFrZlZOzXrv+OIGJR0BHARaWiusyLiRkknAAsj4oKi6AHAORUcbvAM4CDg01Mch5l1oaolxHrZkyaYmbVFNPfUVkRcCFxYt+74uvufbtoBm2tdUlevfUgX3q42qKW7d5lZyzQ5F7eCK7NmVl1Vbw5onwWs6mawTd02v0pm1loVzzKuzJpZZVW9NaBd3NXLzKZS1XOxK7PtMpQ3yo+Wl5//dObjef8y3ff4Olnlb1m+Semya/XclbXvHHcPzM0qf/szG2WVf+DJ8tP89j+eN7xy37LhrPKqUJdNZUxf2eyuphV6GWyCokcMzik/R6kGyufK3r686WnVmzksekb5GModcj0zJ+RMFZ05ba96ysc+3J9XbRialRfL4Jzyz3NwzaxdM7RW3u/wnLXLTwu78Vp5U7nPW2NJVvmNZj5Zuuw6veWnvi2r6rnYEx6YWSVFQAz3lFq6gaTXS/qZpJslbV6sO1TS3lMdm5lNX52Qiyd1ZEk9kp7TrGDMzGpFlFumO0nvBn4M3AbMB0aaOnvxdOJm1mLNzMWS9pV0q6Q7JH18lDLvkHSTpBsl/WC8fY5ZmZU0S9LXJT0s6TZJ9TOAbQi07ryymXW3KLlMf8cCH4iIjwK1fZB+C2w/JRGZWfdoUi6W1AucDryedGHrgZIW1JXZCjgO2C0iXkia/XBM43V+OR54U/F3HeCfJL0MeG9EjHT4qXavYDPrUNUfqLuNtqLxRA5PAWu3ORYz6ypNzcU7A3dExJ0Aks4B9gduqinzAeD0iHgMICIeGm+n43UzeCepNeBrEfEFYCdgR+AHkkYe2x3tImbWfm6ZHXE/sHWD9a8G/tjmWMys25TPxXMlLaxZDqvb02bAvTX3Fxfram0NbC3p15J+K2nf8cIbr2V2E+Dmlc8l4h5JewKXAucAR493ADOzCemAgbrb6Azgq5IOLe5vLulVwBfxrGBm1kp5ufiRiNhpkkfsI52N2gOYB1wh6cURsWSsB4zlAeD5wN0jKyLiweLq2cuA70wuXjOzMXRHq+u4IuKLktYBLgFmkfLvcuCUiDh9SoMzs+mvebn4PmDzmvvzinW1FgO/i4gB4C5Jt5Eqt1eNttPxuhlcBryrfmVE/BnYqwjCzKxFVHKZ/iLiE8BcUp+zXYANI+KTUxuVmXWHpuXiq4CtJG0paQZwAHBBXZmfkFplkTSX1O3gzrF2Ol7L7Gd59tSJAETEA5J2B147XuRmZhPiltmVJL0T2BvYiKIhYmRCi4jYb+oiM7Npr0m5OCIGJR0BXEQaWvCsiLhR0gnAwoi4oNj2Wkk3AUPAxyLi0bH2O2ZlNiLuAe4ZY/sDwNl5T8XMrCRXZgGQdDJpeJrLSBeD+ZUxs/ZpYsaJiAuBC+vWHV9zO0jXZJW+LsvT2ZpZNQXEcHd0ISjhvcCBEXHuVAdiZl2mA3KxK7MTNZw3rzbDef/WaPmK0mVnLsmL5dG/rJFVftHTm49fqNCvvLmv+zU4fqHCXcs3ytr3bU/klX/ykfKvy9qP5H2xZzyR97owUP51ITI/i53E7Y8jeoBrpzqIiYhesWKd8j81PSv6xy80UrY/8yesL7N8b/nvofozP6xDmTmht7d8LL2Zk3vOKP+ax6y813BwTl4sK9Yqn1tXrJuX+2astyyr/Lx1Hy9ddqu1H87a93Nn55WfN2PMs+yr2aD3qax9l1LxXNwdk5qbWWcKlVumvzOAg6Y6CDPrUhXPxW6ZNbPKUsVbA9poXeBdkvYBFgEDtRsj4sipCMrMukPVc3GplllJl0pat8H6tSVdWnIfm0u6TNJNkm6UdFSDMutJOl/SIkm/l/Simm0fLR53g6QfSppV5rhm1qHKzjhT8STbJAtI3QxWkEaYeXHN8qLRH/ZsJXPxOpL+W9J1RZlDaradVOThG4oRFsxsOuuAXFy2ZXYPYEaD9bOAV5XcxyDw9xHxB0lrAVdLuiQiaufj/Ufg2oh4s6RtgNOBvSVtBhwJLIiIZyT9mDQ22bdLHtvMOk7XdCEYV0Ts2cTdlcnFhwM3RcRfS9oQuFXS94F9SFOabw/MBC6X9POIeKKJ8ZlZpVQ/F4/ZMitpR0k7Fne3G7lfLC8DDuPZMzc0FBEPRMQfittPkqbJrZ+PdwFpqlwi4hZgvqSNi219wGxJfcAc0vA0ZjadNbE1QNK+km6VdIekj49S5h01LZY/aMIzqJySuTiAtZQGsl0T+AupErwAuCIiBiPiaVKXh3HnTTezDtfhLbMLWRXixQ22PwN8OPegkuYDOwC/q9t0HfAW4FeSdga2AOZFxNWSTgH+VBzz4ohoFA+SDiNVspnFnNzQzKxKmpQcJfWSzvTsQ5oq8SpJF9S2RkraCjgO2C0iHpOUNxxGixX/2B9OqlAGcBPwbxHx4CT2OZ/Gufg00qw89wNrAe+MiGFJ1wGfkvQlUqPCnkUc9ftdmYdnzF53ouGZWVVUvDvXeH1mtwSeR5qjbOfi/siyGbB2RJyVc0BJawL/CXykwampLwDrSrqWVEm+BhiStB6wf3HcTYE1JDW8sjcizoiInSJip353qzXrbM1rDdgZuCMi7oyIFcA5pJxS6wPA6RHxGEBEPNSEZ9AUknYD7iBNL/4MsAx4N3C7pF0nuM+xcvHrSH10NyV1KThN0tpFI8KFwG+AHwJXkmboWc1qeXjmmhMJz8yqpJNbZosZwKBJQ3hJ6iclz+9HxHkNjvcEcEhRVsBdpPl4XwfcFREPF9vOA14BfK8ZcZlZBQU5/bTmSlpYc/+MiDij5v5mwL019xcDL6/bx9YAkn5Nmmbx0xHxi6yYW+cUUuXxgxFpYGFJPcDXgS+R8mFp4+ViUh7+QjETzx2S7iJdePb7iDgROLHYzw+A2yb2lMysI+Tl4ilRemguSfOAV1MzL/iIiDi1xOMFfBO4ebTyxYgJS4uWk0NJfbOekPQnYBdJc0itEnuTukCY2TSm8mOiPxIRO03ycH3AVqQLXucBV0h6cUQsmeR+m2F74OCRiixAcdr/VNIZrNLK5GJSl669SV2+NgZeANxZdNdYNyIelbQdsB2Nu6CZ2TSSkYunRKnKrKR3A2eRLgB4mNUbkwMYtzIL7Aa8B7i+6EYAafSC5wBExNeBbYGzJQVwI/D+YtvvJJ0L/KGI4RrSIOJmZmXcB9ROZTePZ1+8uhj4XUQMAHdJuo1Uub2qPSGO6XFSN6tb69ZvCSzJ3FeZXPxZ4NuSrid1M/uHiHikGBLxV6k+zBPAQRGRMV2dmVnzlW2ZPYF0KuuTEZE5B18SEf9HSopjlbmS4lRfg22fAj41kWNXQTpbV54ypjOd+XjeW9L3UPmpCwFu+Msmpcv2ZHaamdkzMH6hwj1L18/a9z2P5pXvf7j86zL74cxpFB9bnlVeK8q/LrmfrVyt3v9YmjhQ91XAVpK2JFViDyD1P631E+BA4FuS5pJy0Z1Ni2ByzgG+KelYUn9VSJXSk0jdD0ormYvvB17bYP0y0gVo5Y/XC8vXKd9Tre+Z8t/D/pmNRowcnfrzch+DOdNKZ35YlXnaNmM629xpeyNjWuDhmXn7Hpid9zwHMrpYD6+V93/U3HXypnmdv1b5KWS3XSNvgKVtZuaV37T3ydJlN+htfs6u+qQJZT+VGwNnTrQia2Y2IU3qpxURg5KOAC4i9Yc9KyJulHQCsDAiLii2vVbSTaSLmj4WEeV/zVrrWFIF9CxW5e0B4GtAw2HGzMyaZpr0mb2QdLFEVVopzGy6a/LVsRFxISmX1a47vuZ2AEcXS6UU1xEcJek40ggzAH+MiKVTGJaZdYMOmGmxbGX2EuAkSS8ErufZ84I3uhrWzGxyKp5A2y0ilhYjC+CKrJm1TcVzcdnK7L8Xf/+xwbYgnbYzM2uqqvfTaidJHyG1Gm9W3L+fdPHtl2MqOzab2bRX9VxcqjIbEU0ZZ9bMLEvFE2i7SPoiaUatk0kTFQDsChwPbELqU2tm1hoVz8V5lyWambVTxRNoGx0KHBoR59asu1TSraQzZ67MmlnrVDwXl2pxVfL/JN0oaamk5xbrPy7pHa0N0cy6kaL80iUWjbLOZ87MrGU6IReXTYJHAf9EmqigdnyG+4Ajmh2UmRkAwyq3TH/fAQ5vsP5DwHfbHIuZdZuK5+Ky3Qw+CHwgIn4m6Z9r1v8BeGHzwzIz66pW1/HMBN4l6XXAb4t1Lwc2Bb4v6asjBSPiyCmIz8ymsarn4rKV2S2AGxqsHwBmNy8cM7MaFU+gbbQNqfEAUj4G+HOxbFtTzq+YmTVfxTNL2crsncCOwD11698A3NTUiMzMALqrP+yYImLPqY7BzLpUB+TispXZU4DTJM0h9ZndVdJ7SFfQ/m2rgmuK4Yx3oKeF/T2Gh7OKx4qB8QsV+p9YkbXvWY/kzWd+/6PrlI+lN2/G4/6e8uUfeipj0m5g2aN5Jw3WfrD8+z/74fLvD0Dv489klWfZ8vJlB/LmJ2eohbNS53zfyqh4ArXxRS+sWKv8d2vGk+WvZ5s5uz8rlt4ZeeUZLP9dUeZnP3doYKn8a6i+vIGKor98+aGZecPKD87K+10dmlP+demfk5eHN5idN8/IpjMfL1128/68ma837X0yq/xfZbzs6/WukbXvUiqei8uOM/stSX3A54A5pAsO7geOjIgftTA+M+tmFU+g7SRpY2A3YCPqLt6NiH+bkqDMrDtUPBeX/ncsIr4BfEPSXKAnIh5qXVhmZtU/tdUukg4CziSdGXuM1X9aAnBl1sxapuq5OHvShIh4pBWBmJnZqE4EvgicEBGZ/UrMzKa3UpVZSeuTkuneND7FtXbzQzOzrlfx1oA2Whv4tiuyZjYlKp6Ly7bMfhPYgTRpwv1U/mmZWcfrgCto2+j7wBuBf53qQMysy3RALi5bmd0b2CciftfKYMzMVpM3CMh0djTwE0l7A9eTxvheKSJOmJKozKw7VDwXl63MPgQ81cpAzMxqieq3BrTR3wH7Ao8Az+fZF4C5MmtmLdEJubhsZfYTwAmS3hcRrtSaWXtUPIG20SeBv4+If5nqQMysC1U8F5etzP4TMB94SNI9PPsU13ZNjsvMul0H9NNqo17ggqkOwsy6UAfk4rKV2XNbGoWZWSNNTKCS9gW+QqoYnhkRX6jbfjBwMnBfseq0iDizeRFMyreAd+PuBGY2FaZDZTYiPtPqQMzMnqVJCVRSL3A6sA+wGLhK0gURcVNd0R9FxBHNOWpTzQEOlfQ6YBHPPjt25JREZWbdYTpUZkdI2gtYQHpaN0bE5a0IaspkzK0d5acPB0CZ83AT5S8d7Hkmb37qmY/lxfL0ozNLl72/f52sfff1lZ/7/OknZ2Xte8ajeXOIz36k/Gs+89FlWfvWU3lzgsfyFeXLDpV/DSF/Tvic70WzNfHU1s7AHRFxJ4Ckc4D9gfrKbFVtC1xT3N6mblulf2aiB4Zmly8/OFulyw7PyPuO9/TnzROkvvL7j+HMfed+r3rKvy705cUS/eWf53B/RhzA8Iys4gzNKP+6zJ6ZN+zy2v15eXudvvJ5e42e5Vn7nqW84QH6lT3HVVNNi24GkjYDzgdeShpnFmBTSQuBN0fE/aM+2Mxsoson0LlFPhpxRkScUXN/M+DemvuLgZc32M9bJb0auA34aETc26BM20XEnlMdg5l1selQmQW+CgwBz4+IuwAkPRf4XrHtba0Jz8y6VpCTQB+JiJ0mecT/Bn4YEcsl/R1wNrDXJPfZNJI2Bg6n5uwY8G8R8dCUBmZm01teLp4SZU+W7wMcPlKRBShO1x1ZbBuXpFmSfi/pOkk3SnpWP1xJW0j6paRFki6XNK9Yv6eka2uWZZL+pmTsZtahFOWWEu4DNq+5P49VF3oBEBGPRsTIucIzSWeiKkHSbsAdwLuAZ4BlwEHAHZJ2zdxXmVx8sKSHa3LuocX6LST9oVh3o6QPTv7ZmVnVNTEXt0ROz89GYeaEvhzYKyJeAmwP7Ctpl7oypwDfKYb6OgH4PEBEXBYR20fE9qSWkqXAxRnHNrNOFCWX8V0FbCVpS0kzgAOoG+pK0iY1d/cDbp5k9M10CvBDYOuIeE9EvAfYGjgH+FLmvsrkYkgXw21fLCOjOjwA7Frk4pcDH5e0af7TMbOO0rxcjKR9Jd0q6Q5JHx+j3FslhaRxz7qVrcz+EvhXSStbNiQ9B/hysW1ckYxMuNBfLPVPfQFwaXH7MtIFGvXeBvw8IvKuqDGzjqPhcst4ImIQOAK4iFRJ/XFE3CjpBEn7FcWOLFobryOddTq4Nc9qQrYHvhSx6srQ4vapwA45OyqZi0d77Iqa1uuZ5DWImFmHalYurhlZ5vWkOt+BkhY0KLcWcBTwuzLxlU1ERwJrAHdKuqeYOOGPxbrSQ8JI6pV0LWl63Esioj7I64C3FLffDKwlaYO6MgeQWihGO8ZhkhZKWjgQeVcumlmFlG0JKNkaEBEXRsTWEfG8iDixWHd8RFxQ3D4uIl4YES+JiD0j4pZmP6VJeBzYssH6LYEluTsrkYshXQy3SNK5dQ0Zm0taRLqg7qRGFwDX5uGhpU/nhmdmVdLcXLxyZJmIWEE6u9So4fKzwEmkLlXjKlWZLa7o3RF4A+l01ynA6yNix4hYXGYfxX6GitNT84CdJb2orsgxwO6SrgF2J/VpWznuUHEa8MWk1pXRjnFGROwUETv1K28oJzOrDmUsXeAc4JuS3l10ldhS0kGkvr2j/nM/mhK5+L+B+UWXr0tIF8ONPPbeYv3zgfcVF6bV739lHu6ds0ZueGZWIU3OxY1GltlsteNJOwKbR8TPysZYeuCySINTXlIskxIRSyRdBuwL3FCz/n6KlllJawJvjYglNQ99B3B+ROQNrGpmnaniV9C20bGk34qzWJW3B4CvAaP2ORvPGLn40ZpiZwJfbPDY+yXdALwKzxJpNr01b5jEMUnqIXWfOrj0Ecno7yTpbyRdIemRYvmVpDdnPH5DSesWt2eTRkG4pa7M3OKJABxHSty1DmQCrRBm1pmqfgVtuxR9VY8C1iP1n90eWD8iPlqcqiutZC5ueDGcpHnFY5C0HvBK4NYJPCUz6yAZufiRkbMyxVJfkR1vZJm1gBcBl0u6G9gFuGC8i8DKTprw98DngO8A3y5W7wr8QNInI+KUErvZBDi76PzbQ7oA46eSTgAWFv3W9gA+LymAK0hjKo7EMJ/0AvxvmZjNbBrogopqjuLC1+snuZsyufjI4sK4QeAvrGol2Rb4UpGjBZwSEZONx8yqrnm5eOXIMqRK7AGkIQfTYSIeB+aO3Jd0OXBMRCxkDGW7GRwDHBER36hZd5ak35OG0Bq3MhsRi2hw1W1EHF9z+1xGOV0VEXdT169ifJE1LWyevGkUs2VMOaqBvOlMZzyV96nsf7z8BcvLZpef+hZA/Rnvz5P9WfvufyKvN+XMJeVfx54nnsnadyzNLL8io7Etczrb7OlpW/YdKnPsqTt0FUh6PakrwXYR8UTdtnVIF81+ICJKd/8qmYuPI50dqy9zCbBd6ScAhGAo46s7NKN109nSm1k+Z1rYwczvIZnlezJi780cZKKnfPnozZzOti+vfPSW/9L39+a9hv09meWV+56Wl5tVBzLy8PJW9MRsUi6OiEFJIyPL9AJnjYwsw6p/prOV/aauSRoqq95lxTYzs+bqki4E4zgCOLm+IgupBUPSScBHaMK1DGZmDTU5F0fEhcCFdeuOH6XsHmX2WfbfsZ/QeMrat1I38LiZWdM0cWiuDrUd8D9jbL8UeEmbYjGzblXxXFy2ZfYO0kwvewJXFut2KZZTJR09UjAiTm1uiGbWrdwyy4aMfUYygPqxuM3MmqrqubhsZfZg4DHS9Ilb16x/DDik5n6QhlQwM5u0MjPKTHOLSa2zt4+yfTtWvxLYzKzpqp6LS1VmI6LRzDNmZq0z/bsQlPEz4LOSLoyI1a4ilDSHdAFu6YHFzcyydUAuzrhU08yszSqeQNvgRNL1CrdJOo1V48FuS7o4TKRhE83MWqfiubh0ZbaYIGFPYCPqLhyLiHc0OS4z63Ki+v20Wi0iHpL0CtLwXJ9j1YyRQRra5vCIeHCq4jOz6a8TcnHZSRO+BHwY+DXwINkD5JmZTUDFE2g7RMQ9wBuKGbeeT/ptuT0iHpvayMysa1Q8F5dtmX0f8PaI+K9WBmNmVksZk4dMN5K2jIi7Ru4XlderRikrYF5E3Nuu+Myse1Q9F5cdZ3YpdXN3m5m1VNlxDaudYyfjSknflLTraAUkrSfpQ8BNwP7tC83MukYH5OKyLbNfAI6V9HcRMdjKgMzMRlS9n1aLbQN8AviZpGHgauB+YBmwHrCAdCHY74GPRMRFUxWomU1vVc/FZSuz3wD+GrhP0m3AahP/RsRezQ6sKQIiYx569WTMIZ07v33mlOBZhvIGgOtbnln+6fKDXgwszXui0V9+TvC+pXnzjfctzSpO3zPlu4LrmeVZ+x5esSKrfKxowdzaK3feugEDc75v5XbY3N11kohYAnxM0vHAG4FXAlsAs4FHgLOBiyLihikLsgRlToUZGWmYnLIAvXk5hJzfhJyykPlEMylv35FTPjfsFj7N4czXcCiz/PLh/tJll0X5sgBPZuwboIfyvwnLIu/3qZSK5+KytZSvkxLpL0gXgFX8aZnZdFD11oB2KMaXPbdYzMzaruq5uGxl9p3AmyPiklYGY2a2UlR/1hkzs2mvA3Jx2XMuD+MpE82s3Zp40YGkfSXdKukOSR8fo9xbJYWknSYZfUtImi1pswbrXzgV8ZhZF6j4BWBlK7OfAk6QtGYrgzEzGzEyUHeZZdx9Sb3A6cDrSRdOHShpQYNyawFHAb9r6pNpEklvA24nXRS2SNLLazZ/d4rCMrNprJm5uFXKdjP4GDAfeFDSn3j2BWDbNTkuMzNo3tiGOwN3RMSdAJLOIQ1ldVNduc8CJ5FyXhX9E/DSiHhQ0kuBsyV9LiJ+QEsvtTGzrlbxcWbLVmZ94YGZtV0T/9PfDKidUGAxUNuqiaQdgc0j4meSqlqZ7R+ZvjYirpb0auB8Sc/HF+aaWYtMiwvAIuIzrQ7EzGw1eX2w5kpaWHP/jIg4o+yDJfUApwIHlz7i1HhI0nYRsQggIv4iaR/SMF0+Q2ZmzdcBk9OUH0AUkLQXqb9ZADdGxOWtCMrMDLKuoH0kIsa6YOs+YPOa+/NY/aLWtYAXAZenmWH5K+ACSftFRG0leaq9B1ht4pqIWEHqA3za1IRkZtNd1UczKFWZLa6cPR94KWkGGoBNi5aQN0fE/aM+2MxsoprXGnAVsJWkLUmV2AOAd608TMTjwNyR+5IuB46pWEWWiFg8xrZftzMWM+si06Rl9qvAEPD8iLgLQNJzge8V297WmvDMrJs1q59WRAxKOgK4iDQf31kRcaOkE4CFEXFBc47UGpLOGmVTkKa3vQP4kRsWzKwVpkWfWWAfYI+RiixARNwp6Ujgly2JzMy6W9DUK2gj4kLgwrp1x49Sdo+mHbg5NgReBQwDI9PXvog0gsHVwFtIwye+KiKunZIIzWx6anIuboWcPrONnkm1n12mnHnl1dvCQCBvbu3c+cYz37WeoYyyA3mjAw3nTAmeEcfEyme8MIOD45epESvKz6sNEEPlg1funPCZcr4XzVb1flpt9GvgKeD9EbEUQNIc4BvAdcAbgO8AXwL2nqogR5PzXczJN9m/QBX/Qe4ImS9h7nc4p/zQcN5v37Kh/qzyS4dnlC775NDsrH0v0Yqs8kMZI+/Nyv3xK6HqubjsJ+GXwL9KWnkBhaTnAF/GLbNm1gKdMFB3Gx0FnDBSkQUobp8IfLS4COwkYPupCc/MpqtOyMVlK7NHAmsAd0q6R9I9wB+LdUe2Kjgz62IR5Zfpb01gkwbr/6rYBvAEmSPUmJmNqwNycanKbETcC+xIOpV1SrG8PiJ2HOvq2kYk9Uq6RtJPG2zbQtIvi2kaL5c0r2bbcyRdLOlmSTdJmp9zXDPrPFVvDWij84FvSnq7pPnF8nbgm8B5RZmdgdvK7nCcXPxqSX+QNFhMoVu7zbnYrMtUPReX/i8+IgK4pFgm4yjgZmDtBttOAb4TEWcXY9p+njSuIqT+YCdGxCWS1iRdCGFm01l3VFTL+CBpUofvsSpvDwJnAccU928GPpCxz7Fy8Z9IE0gc02Cbc7FZt6l4Lh6zZVbS6yXdLelZyU7SOsW2fcoerGhpfSNw5ihFFgCXFrcvI82djqQFQF9EXAIQEU/V9h0zs+mp6q0B7RIRSyPig8D6wA7Fsn5EfCgini7KXFt2JIPxcnFE3F3MMjZc9zjnYrMuVPVcPF43gyOAkyPiifoNxSDjJwEfyTjel4FjGf0/+etIQ8wAvBlYS9IGwNbAEknnFafFTpYajycg6TBJCyUtHGB5RmhmVikBDEe5pUtExNMRsahYnp7Err7M2Ll4NKVycW0eHlw6mTDNbMp1QC4erzK7HfA/Y2y/FHhJmQNJehPwUERcPUaxY4DdJV0D7E6aqWeIdFrtVcX2lwHPZZQ51CPijIjYKSJ26mdmmdDMrKqi5NIFJG0s6QRJ50r6D0mfkbTxBPZTJhePplQurs3DfXPWmMBhzKxSKp6Lx6vMbsjY/7kHsEHJY+0G7CfpbuAcYC9J31ttZxH3R8RbImIH4BPFuiXAYuDaiLgzIgaBn5AuSDOzaazqp7baRdJupFm+3gU8Q5r1693A7ZJ2zdzduLl4DM7FZl2o6rl4vMrsYlLr7Gi2I7WejisijouIeRExnzQv+qURcVBtGUlzJY3EdBzp4gZI86qvK2nD4v5ewE1ljmtmHaziw8G00SnAD4GtI+I9EfEe0in/c0gTJZRWJhePwbnYrBtVPBePV5n9GfBZSc+a2qKYfeaEosyEFafN9ivu7gHcKuk2YGPSgOBExBDptNYvJV1PGsP3G5M5rplVXKRZZ8osXWB74EsRsfLZFrdPJV0MNmm1uVjSyyQtBt4O/LukG4tjOhebdZsOyMXjDc11IvA24DZJpwG3FOu3JV0cJuBzuQeNiMuBy4vbx9esPxc4d5THXMLYrcSjHKxFr260dgpResvPlxv9eXPrDs3Iiz1nBsDhzCHbo7f8f3KROYXwcN7MhURvC9/T3M/hcPnpCKPVn8Upkmad6YpW1zIeB7YEbq1bvyWwZKI7HSMXXwXMG+Uxebl4GHozrsXtGSj/nmsw83s11MLyuRe/ZH+2M2LJ3LeGy+87e3rawbxYcqZEHxjI+1F4aiDvOprHB8tPUbukb07Wvmf15E1xnjOdbX+Tp7PthFw8ZtUjIh6S9Arga6RK68irGcBFwOER8WBrQzSzrtUdra5lnEOaNOFY4DfFut1II8r8cMqiMrPuUPFcPG47WkTcA7xB0nrA80kV2tsj4rFWB2dm3a3qrQFtdCwp955FytsCVpAaGj4+hXGZWReoei7OmQHsMVLnfzOz1uuiYbfGExErgKMkHQc8r1j9R09YYGYt1wG5OLOHo5lZu3TNSAUNSbqgRBkAImK/cYqamU1Q9XOxK7NmVlndMIbsGB6d6gDMzKD6udiVWTOrroq3BrRSRBwy1TGYmQGVz8XjjTNrZjY1OmBsQzOzaa/JuVjSvpJulXSHpGddwCrpaEk3SVok6ZeSthhvn67Mmll1VXzWGTOzrtCkXCypFzgdeD2wADhQ0oK6YtcAO0XEdqS5B7443n5dmTWzytJwlFpK7Wv81oAPSrpe0rWS/q9BgjUz60pNzMU7A3dExJ3FKC3nAPvXFoiIy2pGavkto0zgUsuVWTOrrva2BvwgIl4cEduTWgJObfKzMTPrTM07S7YZcG/N/cXFutG8H/j5eDv1BWBmVk1BM2edWdkaACBppDXgppWHi3iipvwaVH5kRTOzNsjLxXMlLay5f0ZEnDGRw0o6CNgJ2H28stO/Mtui/nSROQ93+VmVi/J95d+awTkzsva9Yq28BvnBtco/11hjMGvf6iu/76HIexUH18ibt3tgzfLlZ83Km+MbtfAkyDTtMyoiZ9aZ8RJoo9aAlz/rmNLhwNHADGCvvIitEQX0Liv/Ge1bXr5sz2DefzsazJyzfiij/HAL9w3Qm5HPhjL/CxzKeM0H8vbdM5AXSk75wYG8HP/MYH9W+ScGZ5Uu+/jQnKx9z8p8YYai/G/IrJ4VWfseT2YufiQidhpj+33A5jX35xXrVj+m9BrgE8DuEbF8vINO/8qsmXWu5iXQkoeL04HTJb0L+CfgfZPdp5lZx2teo8lVwFaStiRVYg8A3lVbQNIOwL8D+0bEQ2V26j6zZlZdzeunVao1oMY5wN9MPHAzs2mkSbk4IgaBI4CLgJuBH0fEjZJOkDQyk+HJwJrAfxQX5I47G6JbZs2smprbZ7ZMa8BWEXF7cfeNwO2YmXW75uZiIuJC4MK6dcfX3H5N7j5dmTWzysropzWmiBiUNNIa0AucNdIaACyMiAuAI4p+WgPAY7iLgZkZ0Lxc3CquzJpZdTUxgZZoDTiqaQczM5tOXJk1M5sIz+5lZjb1qp+LXZk1s2oKsoYMMjOzFuiAXOzKrJlVVtX7aZmZdYOq52JXZs2suiqeQM3MukLFc7Ers2ZWTQFkzrRnZmZN1gG52JVZM6uo6l90YGY2/VU/F7sy2y5SXvn+8m/NwNp5800vWz8vloF1B0uXnbXOuFMor6a3t/xIzM/0zcja9/Kl5efVBnhm/fLzfK+x1uysfWvWzKzyMZgxb3fFk8ykTOfn1iU0DH3PlC/fu6z8e67lQ3nBDOWVj8GM8rn7HsobhT4ra2fGoozyyrwQqDcjlQH0rCj/TIeXl8/ZAM8M5P1WPj1YPm8/OZT3ezOnZ0VW+Z6MWQuG8j4t5VQ8F7sya2bVVfEEambWFSqei12ZNbNq6oB+WmZm014H5OK2VmYl3Q08CQwBgxGxU9329YCzgOcBy4C/jYgbyjzWzKabgGjihOC2Gkm9wELgvoh4U922fwH2LO7OATaKiHWLbScBbyy2fTYiftSeiM1salQ/F09Fy+yeEfHIKNv+Ebg2It4saRvgdGDvko81s+mm4qe2OtxRwM3A2vUbIuKjI7clfRjYobj9RmBHYHtgJnC5pJ9HxBPtCNjMpkjFc3HPVAdQZwFwKUBE3ALMl7Tx1IZkZlMigKHhcotlkTSP1Lp6ZoniBwI/LG4vAK6IiMGIeBpYBOzbmijNrBI6IBe3uzIbwMWSrpZ0WIPt1wFvAZC0M7AFMK/kYyked5ikhZIWDpB3Zb2ZVUxEucVyfRk4Fsa+RFrSFsCWFI0MpBy9r6Q5kuaSuiJs3uBxK/Pw4LKnmxq4mU2BiufidnczeGVE3CdpI+ASSbdExBU1278AfEXStcD1wDWkPrJlHgtARJwBnAGwttb3r5xZx3JFtRUkvQl4KCKulrTHOMUPAM6NiCGAiLhY0suA3wAPA1eyKkevVJuH15i7ud9Es45W/Vzc1pbZiLiv+PsQcD6wc932JyLikIjYHngvsCFwZ5nHmtk0E8DwcLnFcuwG7FdcVHsOsJek741S9gBWdTEAICJOjIjtI2If0vCnt7UyWDObYh2Qi9tWmZW0hqS1Rm4DrwVuqCuzrqSRkfEPJfXNeqLMY81sGqr4qa1OFBHHRcS8iJhPqqxeGhEH1ZcrLsJdj9T6OrKuV9IGxe3tgO2Ai9sSuJlNnYrn4nZ2M9gYOF9pJqw+4AcR8QtJHwSIiK8D2wJnSwrgRuD9Yz22jbGb2VRwRbVtJJ0ALIyIC4pVBwDnRKz2JvQDvypy8RPAQRFRfopAM+tMFc/FbavMRsSdwEsarP96ze0rga3LPnYqqSdvujj15k27FzPLT926Yp28t3H53LwP5ey5S0uX3Wy9x7P23d9TfhrFx2bnTSH74GDeiYelf1V+6sIVc9fI2vesh+ZklY9l5S9ezJr6FiqflFaJyg/U3eki4nLg8uL28XXbPt2g/DLSiAalaRj6Mqao7V2WMbXqQOZ0tjnT0wIMlq+nx0BmnT7ze5hVOvd0b8ZV6D0DefvuGch7njnT2TKQl+OfWZE3ne1TA+V/E54aypuyfJ2+vN/tmZExnXvTz/ZXPxd7BjAzq6aAqPhA3WZm014H5OKqjTNrZrbKcJRbSpC0r6RbJd0h6eMNth8t6SZJiyT9shiWyszMmpiLW8GVWTOrriZddFBM3Xo68HrSafIDJdWfLr8G2CkitgPOBb7Y5GdjZtaZKn4BmCuzZlZNEc0cDmZn4I6IuDMiVpCGpNp/9cPFZREx0kH8t6yasMXMrHs1Nxe3hPvMmlllxVDpC3bmSlpYc/+MYuD+EZsB99bcXwy8fIz9vR/4edmDm5lNZxm5eEq4MmtmFZV12uqRiNipGUeVdBCwE7B7M/ZnZtbZqj+etyuzZlZNQTMvKLgP2Lzm/rxi3WokvQb4BLB7RJQfH83MbLpqbi5uCVdmzay6mjcczFXAVpK2JFViDwDeVVtA0g7AvwP7FtNmm5kZNDMXt4Qrs2ZWSQFEk1oDImJQ0hHARUAvcFZE3Fg369XJwJrAfxQzXP0pIvZrSgBmZh2qmbm4VVyZNbNqimhqa0BEXAhcWLfu+Jrbr2nawczMposm5+JWcGXWzCqr6q0BZmbdoOq5WFHxK9QmQ9LDwD11q+cCj0xBOI04lsYcS2PTMZYtImLDRhsk/aI4ThmPRMS+TYjHmmyUPAzT8/PcDI6lMcfSWDNiGTUPQ2fk4mldmW1E0sJmDeEzWY6lMcfSmGOx6aRKnyHH0phjacyxVI9nADMzMzOzjuXKrJmZmZl1rG6szJ4xfpG2cSyNOZbGHItNJ1X6DDmWxhxLY46lYrquz6yZmZmZTR/d2DJrZmZmZtOEK7NmZmZm1rGmbWVW0r6SbpV0h6SPN9g+U9KPiu2/kzS/zcffQtIvJS2SdLmkeTXbTpJ0Q7G8c5JxnCXpIUk3jLJ9PUnnF3H8XtKLarZ9VNKNRRw/lDRrkrFsLukySTcV+z1qquKRNKvY/3XFPj/ToEzD90jSnpKurVmWSfqbicZS7LNX0jWSflo2jmLbcyRdLOnm4nWdP5k4in3eLen64rktbLB9rPdozMdadymRfyTpq0WeXCRpx3YevyizR/F5vVHS/xbrxs0PE4ilTP57d/E6XC/pN5JeUrNtXUnnSrql+L7v2uJY1pH03zWvwSE125r5G1UmFx8s6eGanHtosX4LSX+oef8+OJlYin2OlYtfXRxvUNLb6ra1IhePFcu/1Lwet0laUrOtae9Px4iIabeQ5l7/I/BcYAZwHbCgrsz/A75e3D4A+FGbj/8fwPuK23sB3y1uvxG4hDQ72xrAVcDak4jl1cCOwA2jbD8Z+FRxexvgl8XtzYC7gNnF/R8DB0/yddkE2LG4vRZwW4PXpS3xAALWLG73A78DdinzHtWVWR/4CzBnkq/N0cAPgJ822DZqHMDlwD7F7TUnG0exn7uBuWNsb/gelXmsl+5aSuSfNwA/L76PuwC/a/Px1wVuAp5T3N+o+DtufphALGXy3yuA9Yrbr699PYCzgUOL2zOAdVscyz8CJxW3Nyzy3Aya/xtVJhcfDJzW4LEzgJnF7TWL/LPpJN+nsXLxfGA74DvA2+q2tSIXjxpLXbkPA2cVt5v6/nTKMl1bZncG7oiIOyNiBXAOsH9dmf1JyQHgXGBvSWrj8RcAlxa3L6vZvgC4IiIGI+JpYBEw4dk0IuIKUhIazco4IuIWYL6kjYttfcBsSX3AHOD+icZR7P+BiPhDcftJ4GZSJbXt8UTyVHG3v1jqr4Yc7T2q9Tbg5xGxdKKxFC2tbwTOHKVIwzgkLQD6IuISgIh4ajJxZBjrPTJbqUT+2R/4TvF9/C2wrqRN2nj8dwHnRcSfivIPFX/L5IfcWMbNfxHxm4h4rLj7W2DkbNA6pIr5N4tyKyJiSStjIT3ftYrfxTVJr+Mgzf+NmvBrXbwOy4u7M5nk2ebxcnFE3B0Ri4Dhusc1PReX+F2odSDww+J2U9+fTjFdK7ObAffW3F/Ms7+oK8tExCDwOLBBG49/HfCW4vabSUljg2L9vpLmSJoL7Als3qS4GlkZh6SdgS2AeRFxH3AK8CfgAeDxiLi4WQctTsHsQPovfEriKU7hXAs8BFwSEaPGwurvUa0DWJVEJurLwLHUJcgScWwNLJF0XnEq6mRJvZOMBdIPycWSrpZ02Fjx1L5HJR9rVqtMrmylrYH1lLrvXC3pvSMbSuSHCRsj/9V6P6nVGmBL4GHgW8V3/UxJa7Q4ltOAbUmNBtcDR0XEMC34jSr5Wr+16IJxrqTNax67uaRFpM/RSRExmUaXLzN2Lh5NK3JxqVgkbUH6fIw0eLS7DlEJ07Uy2wmOAXaXdA2wO3AfMFRU0C4EfkOqJF0JDLUwji+QWkOuJZ2quAYYkrQeqdVkS2BTYA1JBzXjgJLWBP4T+EhEPDFV8UTEUERsT6qI7ayavp+Fhu9RzfPYBHgxcNFEY5D0JuChiLh6jGKjxdEHvKrY/jJSt5aDJxpLjVdGxI6k05yHS3p13faG71HJx5pVSR/wUlIL2OuAT0raGkrlhwkZJ/+NlNmTVJn9h5o4dwS+FhE7AE8Dz7oWo8mxvA64lpRvtwdOk7R2K36jSrzW/w3Mj4jtSKfQz6557L3F+ucD75voWaKSuXg0Tc3FmbEcAJwbEUMAU1CHqITpWpm9j9X/E5lXrGtYpjhtvQ7waLuOHxH3R8RbisT0iWLdkuLviRGxfUTsQ+pPdFuT4nqWiHgiIg4pEsl7SX2j7gReA9wVEQ9HxABwHqk/16RI6iclz+9HxHlTHU9xzCWk0/f71q0f9T0qvAM4v4hnonYD9pN0N6k7yl6SvlcyjsXAtUV3lkHgJ6QfvEkpWsFHTrmeT+o2U7t9tPdo3Mea1SmTq1tpMXBRRDwdEY8AVwAvqS0wWn6YiPHyX1FmO9Kp5f0jYuQ3aTGwuKbF8lwm+V0vEcshpC4YERF3kK5Z2AZa9xs1Ri5+tKY7wZmkf0DqH3s/cAOpUjkR4+biMTQ7F+fE8qyzg+2sQ1TFdK3MXgVsJWlLSTNIb/YFdWUuAN5X3H4bcGlENGsGiXGPL2mupJHX/zjgrGJ978ip7CKpbQc07fR+PaUrZGcUdw8l9bV5gnQ6f5fiVIWAvUn9qiZzLJH6fN0cEadOZTySNpS0bnF7NrAPcEtdmYbvUY3afkoTEhHHRcS8iJhP+pxcGhGrtTiPEcdVpBbSDYv7e5EuZpkwSWtIWmvkNvBa0g9EbZmG71GZx5rVuQB4r5JdSN2HHmjj8f8LeKWkPklzgJcDN5fJD7lK5r/nkP5Rf09ErKyARMSfgXslvaBYtTeT+K6XiYWUc/cuym8MvAC4s9m/USVzcW0/6v0ocr+kecVjKM7evRK4dSJxlMnFY2hqLi4bi6RtgPVIra8j69pah6iMqMBVaK1YSFfJ3kYaVeATxboTgP2K27NIV4nfAfweeG6bj/824PaizJmsuiJzFulLcBPpAoDtJxnHD0l9TAdI/z2+H/gg8MFi+65FDLeSkuh6NY/9DCmp3AB8dyTGScTySlKfykWk01fXFq9T2+MhfcGvKWK5ATi+7HtUbJtPakHqaeJnZg+Kq1Yz4tineA7XA98GZkwyhueS+lxdB9xY89kd9z0a7bFeuncpkX8EnE7Kk9cDO7Xz+EWZj5Hy7Q2k0+2j5odJxlIm/50JPFazfWHN47cHFhaP/0ltbmxRLJuSKkHXF6/BQcX6Zv9GlcnFny9yynWkltttivUj+e+64u9hTfrc7EHjXPyy4nP0NOlM7o01j2lqLh4vluL+p4Ev1JVv6vvTKYunszUzMzOzjjVduxmYmZmZWRdwZdbMzMzMOpYrs2ZmZmbWsVyZNTMzM7OO5cqsmZmZmXUsV2bNJknS3ZKOmeo4zMzMupErsxUlaWNJX5H0R0nLJd0n6eeS3jDVsVWJpPmSQtJOJcp+QtKvJT0tyWPSmZmZTQOuzFaQpPnAH0hzYx9HGlT6NcDPgK9PXWQdbyZpkP8vT3EcZlZBkr4t6adtPuZ6kh6U9Lx2HtdaQ9J/SPr7qY6j27gyW03/VvzdKSJ+HBG3RsTNEXEaqWILpKkPJZ0v6cliOU/SvJrtn5Z0g6T3FafCn5b0LUkzJP0/SfdKelTSqTXTpY6cNv+0pO9JekrSn+tPo2cc+4CidflJST+RNLduP4dIuknSMkm3SfpoXSwh6bAiQTwt6U5JtdP63VX8vaooe/loL2pEHB8RXyLNNlOKpMslfb1oJX+sWE6ujbEwS9K/S3pC0mJJH6vbz9GSFhXP4T5JZ45M4VhsX0fSdyU9VLwWd0r6SN32M4rtT0r63zKt0WZWef8IXBgRfxxZ4TNz5RU5+rQxtr9a0gXFaxiSDh6j7IaS/q34DVxe/JPxS0n71JT5drGf+mX7osgJwCckrdOs52jjc2W2YiStD+wLnB4RT9Vvj4glRbke0rziGwN7FsumwE8kqeYh84H9gTcBbwHeTpoP/WXAa4FDgQ8Db6471NGk+a93BD4FfE7SWyZw7HcW+34tsANwYs1z/QDwOeB4YFvg74F/AP5fXSzHF8d7CfAj4CylOcwBdi7+7gtsUjzHZns36buyK/B3wGHAR+rKfJQ0jeGOwEnAFyXtWrN9uHjMC4F3FXH/a832fwZeTHqfXgD8LWm63JF51H8GbFZs3wG4ArhUq89ZbmYdRNIcUg7+Zs26+fjMXDOtSZom9yjgmXHK/icpN78f2JqUb38ObFBX7n9Ivze1yw0AEXE9cCdwENY+Uz2frpfVF9IXKYA3j1NuH2AImF+z7rmkStNrivufJn1516kpcy7wMDXzRgOXA6fV3L8buKTueGcC/5d57GV1x/4EcEfN/T8B76k7zkeAm2ruB/D5mvt9wFJWzRM+vyhTek534G3po1+q7OXAbZCmfi7W/ROwuO71+mHd424H/mmM/e4LLAd6ivsXAGeNUnYv4Clgdt36a4Fjp/oz68XLdFmAbwM/LW7PJHVJerDIZb8FXllXfg3gO8X380FS5fOnwLdLHu9twF/q8suFpH9k12xQft2a22PGV+SurwFfKo7xMKlCNxM4HVgySg6+nFRp/grwWLGcPJKrMl6by0lnGT8HPAI8BJxSk/MEHAv8kfQ7df1IXs/Yx7dJ+b92mT/G6/0UcPAo29YtHv+asp+RMcocT/F76aU9i1tmq0fjFwFSS+b9EXH3yIqIuBO4H1hQU+5PEfF4zf0HgdsiYkXduo3q9n9lg/sj+y177Hvqjn3/yHEkbQhsDvx70ZXhKUlPAV8A6vuOLao5ziApKdfH20q/jSJDFa4ENpO0ds26RXWPWflcASTtJemSogvCk6S+uzOAvyqKfA14p6TrJJ0iafeafb0UmAM8XPdavYhnv1Zm1hxfJJ1Z+lvS2ZDrgV/UnQ35ErA76ezTXqSzR6/KOMargKtH8kvZM3MZ8b0beBJ4OSm3fhn4Cekf9J2As4EzG5zhGe9sVJljj+xnEHgFcESxj3cW2/6Z1AJ6OOl34/Ok34M3ZuzjKFI+/harWkjvZWKeKpb9JM2a4D5G/B7YWdLsSe7HSnJltnpuJ/13uO0k9lFb8RposK3RumZ9FsY79shxRv5+ENi+ZnkR6VR8rVbG2yyjxihpC9IpwptJ3TxeSvoRgFShJSJ+DmxBanWYC/xM0reKMj2kfzi2r1u2AT7Z/Kdi1t0krQF8CPiHiPhZRNxMylUPkipfSFqT9D3+h4i4JCJuJFXOhmv2s3nRp/Omos/82+sOtQXpH98Rzyc1aNw82fgKN0bEpyPiduBUUuvmQER8JSLuIPXvFLBb3SEeAI6MiFsi4sekltmjM48N6Szb8RFxW7Gfy4C9i30cDRwaEb+IiLsi4gfAN8ruA6BoLFkBLI2IPxfL0Fiv3WiKhpKDSd0Dlki6smhYeHmD4vvWNixI+nnd9vuBflL3O2uDqlUIul5E/AW4CDiiSJarqblo6GZg06J/1ci255K+PDc1IZRdGtwfSbCTPnZEPEj6wj8vIu6oXzLiHGlh7s14TK6X1/UF3oXUMv1EycfvRKq0fjQiroyI22iQ5CLikYj4bkQcTPpRfJ+kmaT+cxsDww1eq4cm88TMrKHnkSojvx5ZUVSSas9QjZT5fU2Zpyn6ThYGgY9ExALSdQNfLipyI2aTTtOPKHtmrkx8sPpZrSCdpr++Zt0AqRtB/Zmusc5GlT32ascvjJyxWgDMIrXm1p5t+hBjnJmr20fTRcR/knLzX5P6yr4C+K2kf6wregWrNywcWrd9pG+uW2bbpG+qA7CGDiclioWSPkn6Mot0odVxwHNIHdAXAd+XdFTxuH8lVXwubUIMu0g6jtTHdg/gvaTTPTTx2J8C/lXSElI/sX7SBVSbRcTnS+7jIVLieJ2ku4FldV0bViouGluf1M+WmqtP72h0Sq/GpqQfoX8jXaT1MdIpsrJuJ/3j+BFJ55Eqwx+pi+0E0ut3I+l7+RbgzohYLul/SJ+H/5J0LHALqXvCvsD/RMSvMmIxs8kpPUZ1RDxAauUkIv4s6RFSDnq6KPIIsF7NQ2rPzJ3fhPim8szcaMfvqTneX5P67Y71mLaemYuIZcAlxXKCpDOBT0s6paZ73tJxGl3WL/4+3Ko4bXVuma2gov/pjqQv00mkiuOlwH6kvksj/2XvT/qyXFYsfwb+pu4/6ok6lXQV7TWkitvxEXFuM48dEWeSTtO9B7gO+FXx/O4a63F1+xgEjiT9Z3w/adSD0ZxQPJ+Ti/vXFMt4Q1x9n9Ty+zvSabBvAv+SEeMiUt+uo0kt14cC9TOGLSeN9HAdqeK6FinRj7zebyB9Br4B3Ar8mDTqwf2YWbP9kXTWZ+Xpd0m9pD6kN9WUGSCNDDNSZg6pq9SzSHop0BsRtX06r6GmNTPjzFyZ+CZjrLNRzTj2TaSct0WDs033ZMa6gtaembuJ1MCQ04/2RcB9xRlIa4dmX1HmpfMX0tX5x0x1HFVYqBvpwYsXL9N3YfXRDL5MalV9A6ml9AzSBUKb1JT/epEv9yZVSn8APA58q26/65POuryibv2LSSPDbFCz7rnFcW8h9bF/Aal//IdIF/RSJr5GuYvUBeLTdev+DBxRc/9y0kVjXymO/TbSyAfHlD32GMevfX3/GXiU1KDxfNLp+g8Ch5XdR3H/DOBq0hm3udSMulBsX5NV3QGWkkYa2B54Tl25DUgNBgeRGnK2LF7/P1Mzuk/98cf4HH1zqj/P3bS4m4GZmdmz/UPx91ukYZuuAfaN1HVgxDGk4bkuIFXm/oXUv31lP9ii3/tPgC9ExG9qDxAR10v6PXAAabgsIuJOSTuSJlM4iTS+9KOkszaHZcY3UbVno4Jnn41qxrE/Sbpo7BjSaC5PkIYb/GJmrKeQRmW4idRHdUvSPxgjdiKdPRzxmWI5m3TB14inSEOMHUWqXM8kDZH2AzK6lRUjIbyZNE6wtYmK/yLMVir6np4WEadMdSxTTWlGsRsi4oipjsXMqq2ouN4DnBwRXypO1f8AuDUiPj3KY/YltYIuiAleid9MznmTI+lwYP+IeO1Ux9JN3DJrzxIR86c6hqqIiD2mOgYzqyZJO5BOs/+e1M/9H4q/PyqK7EYaE3WRpL8p1r0n0ixRAETELySdDswjVYStsw2QZtW0NnJl1szMbOKOJvUtHSSdJn91RCwGiIj/o8SF1hHx1VYGaO0TEWdMdQzdyN0MzMzMzKxjeWguMzMzM+tYrsyamZmZWcdyZdbMzMzMOpYrs2ZmZmbWsVyZNTMzM7OO5cqsmZmZmXUsV2bNzMzMrGO5MmtmZmZmHcuVWTMzMzPrWK7MmpmZmVnHcmXWzMzMzDqWK7NmZmZm1rFcmTWzriDpLEkPSbphlO2S9FVJd0haJGnHdsdoZjadtSoPuzJrZt3i28C+Y2x/PbBVsRwGfK0NMZmZdZNv04I87MqsmXWFiLgC+MsYRfYHvhPJb4F1JW3SnujMzKa/VuXhvmYFWEUz+ubE7P51SpcfntlbuuzgLGXFMjwrssr39g+X33feruGZ8s8ToG9p+QP0LhvKiyUr+NwnmvceZe0/N5Th8u9n2n/5A0RGWQAp83Xpyfifty/vs/XEsj8/EhEbNtr2uj3XiEf/Uu7zdPWi5TcCy2pWnRERZ2QFA5sB99bcX1yseyBzP1ZjRs+smN2zZvkH5H63MuR+V/KCyfte5WanlsrJCb2ZbWC9eTkh+srvf3hGXixDM7KKMzyz/PvfP2Mwa9+z+wayys9U+f33Ke/35p4bnxo1D0Pbc/GE8vC0rszO7l+HXZ///tLll26xdumyj72gPyuWJ7bN++Cuu/GTpcsuH8h7G4duWSur/MYLy1dQ17z98ax96+lnyhfO/SHKrbTl7H8wr9IeSzOeJxDLl5cvO5CXRNWf93nRGmuUL7zR+ln7vuiGE+8ZbdsjfxnidxfNK7Wf/k3+uCwidso6uLXF7J412XXN/UuXz6pwZv6TGCvy8jCRsX/lVayUWylspYwKZ89aGf+YALFO3u/NwIbl9//0vFlZ+378uXmv+dLnrShddvN5j2bte9v1/pxV/rmzHylddm5f+foDwGHb/N+oeRg6IxdP68qsmXWyYCinMjF59wGb19yfV6wzM+tibc3FE8rDlfjXUNK+km4trl77eIPtMyX9qNj+O0nzpyBMM2ujAIaJUkuTXAC8t7iadhfg8Yjoqi4GHvHBzOq1ORdPKA9PecuspF7gdGAfUt+IqyRdEBE31RR7P/BYRDxf0gHAScA72x+tmbXTMM1rDZD0Q2APYK6kxcCngH6AiPg6cCHwBuAOYClwSNMO3jm+DZwGfGeU7bVXGr+cdKXxy9sSmZlNmWbl4lbl4SmvzAI7A3dExJ0Aks4hXc1WW5ndH/h0cftc4DRJivze/GbWIYJgqIlf8Yg4cJztARzetAN2oIi4YpwzXyuvNAZ+K2ldSZt0Wwu2WTdpZi5uVR6uQjeD0a5ca1gmIgaBx4ENGu1M0mGSFkpauGJoaQvCNbN2aXM3AxtfmXy9eh4eXla/2cw6TNVzcRVaZpuqGALiDIB1Zm/iXzmzDhXAkCuqHWm1PNw312+iWQfrhFxchcpsmSvXRsosltQHrAPkjYNhZh3Hra6V4xEfzLpQ1XNxFboZXAVsJWlLSTOAA0hXs9W6AHhfcfttwKXuL2s2vQUwFFFqsbbp+hEfzLpNJ+TiKW+ZjYhBSUcAFwG9wFkRcaOkE4CFEXEB8E3gu5LuIE2DdsDURWxm7dLWUWbNIz6YWUNVz8VTXpkFiIgLSUmydt3xNbeXAW9vd1xmNnUighVudW0rj/hgZvU6IRdXojLbUhnTHWZNZ5z7vvbmPWCtWeWnM50zs/yUewAPzs6bjnC4r/y0sNGfNw83feXLazjzRc/98g2V/wDEYN4UsgxlTn+bUz5zZpasfQPK2X/m9KJjSQN1W7dRxjTU1f55nZ5a3cNPObv3B6ChoSb3IO2EXDz9K7Nm1qHEEOUrNmZm1grVz8WuzJpZJQWQ2xhvZmbN1Qm52JVZM6usqrcGmJl1g6rnYldmzayS0kDd1U6gZmbTXSfkYldmzayyhqPaCdTMrBtUPRe7MmtmldQJrQFmZtNdJ+RiV2bNrJICNX2IGTMzy9MJudiVWTOrrKqf2jIz6wZVz8WuzJpZJQViRWROwmFmZk3VCbnYlVkzq6Q060y1T22ZmU13nZCLp39lNmek34xp+iLzfe2dlTeF6KZrPl66bF/WPLxw/xpzs8oPzSj/ZIdn5P331ttf/iMYA3lTyGqohdPftnJ62sz9R+Zo1sqaL5K816XJI2tX/aIDKyFaPwWqtU/OdMNQsRlnc4PJSn15r8twZiViKKN8K7oEVD0XT//KrJl1pAhlJXAzM2u+TsjFrsyaWWUNV7w1wMysG1Q9F7sya2aVlMY2rHZrgJnZdNcJudiVWTOrqOqf2jIzm/6qn4tdmTWzSuqEK2jNzKa7TsjFrsyaWWUNVXygbjOzblD1XOzKrJlVUidMoWhmNt11Qi52ZdbMKimAgXCKMjObSp2Qi6sdnZl1rUCVP7VlZjbddUIudmXWzCqr6hcdmJl1g6rnYldmzaySIvKmcDQzs+brhFzsymytjDmnh2fk7XrOGsuyyr9orftLl+3XUNa+f7vWllnlB2fNKl12eGbeR6r36RZ+QXLngx/KeB2Hhlu3byCGM2KPzFhyTxflxNJUqvysM1bScMZnNOd7m7NfyP6u5HwP1ZO571Z+D3vy9q2M1zxy82oLqdWhZLxHuafhBzMrhwPRm1G22VW76udiV2bNrJKC6rcGmJlNd52Qi12ZNbPKqvpwMGZm3aDqubit0UnaV9Ktku6Q9PEG27eQ9EtJiyRdLmlezbaTJN1QLO9sZ9xm1n6BGI5yi5Un6SxJD0m6YYwye0i6VtKNkv63WDdL0u8lXVes/0z7ojazqdIJubhtlVlJvcDpwOuBBcCBkhbUFTsF+E5EbAecAHy+eOwbgR2B7YGXA8dIWrtNoZvZFBmip9RiWb4N7DvaRknrAv8G7BcRLwTeXmxaDuwVES8h5eJ9Je3S0kjNrBKqnovbeeSdgTsi4s6IWAGcA+xfV2YBcGlx+7Ka7QuAKyJiMCKeBhYxRjI2s84XwHD0lFqsvIi4AvjLGEXeBZwXEX8qyj9U/I2IeKoo018s1bkayMxaohNycTuPvBlwb839xcW6WtcBbyluvxlYS9IGxfp9Jc2RNBfYE9i80UEkHSZpoaSFKwaXNvUJmFn7BGIgekst1lRbA+sVXb2ulvTekQ2SeiVdCzwEXBIRv2u0g9XycOSN5GJm1dIJubhqF4AdA5wm6WDgCuA+YCgiLpb0MuA3wMPAlUDDsY4i4gzgDIB1Zm/iVgOzDjZU8eFgpqk+4KXA3sBs4EpJv42I2yJiCNi+6IpwvqQXRcSz+t6ulod75zoPm3W4qufidlZm72P11tR5xbqVIuJ+ipZZSWsCb42IJcW2E4ETi20/AG5rfchmNlUi5C4ENSTNBDYlVTAfjoiHW3SoxcCjRZeupyVdAbyEmpwbEUskXUbq7jXqhWRm1vk6IRe3M7qrgK0kbSlpBnAAcEFtAUlzJY3EdBxwVrG+t+hugKTtgO2Ai9sWuZlNiaHoKbVMV5LWkvShokL5OHAHqfL4Z0l/kvSN4qxVM/0X8EpJfZLmkC66vVnShkWLLJJmA/sAtzT52GZWQVXPxW1rmY2IQUlHABcBvcBZEXGjpBOAhRFxAbAH8HlJQepmcHjx8H7gV0ozdD0BHBQRg+2K3czaL6Dys860kqSjgU8Ad5L+8T8RuB94BlgfeBHwKuASSb8FPhwRt5fY7w9JuXaupMXAp0g5loj4ekTcLOkXpAtth4EzI+KGoiHh7GJkmh7gxxHx02Y+ZzOrnk7IxW3tMxsRFwIX1q07vub2ucC5DR63jDSigZl1DU3rVtcSdgF2b9QntfB74CxJHwTeD+wOjFuZjYgDS5Q5GTi5bt0iYIfxHmtm0031c3HVLgBrvow5qof7y5cdWCPvmoYt134iq/xOc+4qXXZF5hWEs+cszyo/OGt26bLR27r/3pQzNznAUO487Dnzx+fOw54Ze87+KzRXeu6c8GNJw8FUuzWglSLiHSXLLSeNC1tdOZ/RjO9h7vcqcnNI1vc880ru3FhauW9lPM+hhtdejy4792WUz9x3T2boDJXPP4NDee//8qG86tfS4Rmly84aHsja93g6IReXrmpL2ljSMZK+VgyPhaTdJG3ZuvDMrJs1c6DuEjMQPkfSZZKuKWYhfEPTn1AmSdvVXEdgZjYlqp6LSx1Z0kuBW4F3k05njcy+tQ/FCANmZs3UzCkUS85A+E+kfqA7kC5QrUJr5zXA3JE7kn4maZMpjMfMukwn5OKy//GfAnyl2HHtOeqLgN1K7sPMLMswPaWWEsrMQBis+kd9HdLFVlOt/tfh1aShuczM2qbqubhsp42Xklpk6z0AbFxyH2ZmpUXAwHDpM+xzJS2suX9GMXD/iEYzEL68bh+fBi6W9GFgDeA1eRGbmU0/nZCLy1ZmnwHWa7B+G9K0hmZmTZVObZVOoI9ExE6TPOSBwLcj4kuSdgW+W8xwlXe1X3NFsdSvMzNri07IxWUrs/8FfErS24v7IWk+cBLwn5OJ2MxsNE2cQnHcGQhJZ5/2BYiIKyXNIvVXncp/2AV8T9JI965ZwDckLa0tFBH7tT0yM+saVc/FZavax5AG6X4YmAP8H2kmmiWkjrpmZk01MhxMMy46oMQMhMCfgL0BJG1Lqji2asrYss4m9Rd7tFi+RzpF92jdYmbWEp2Qi0u1zEbEE6TpDfcCdiRVgv8QEf9T5vFmZvmaNx94yRkI/57U6vlRUv4+OLIHCG6uiDhkKo9vZtYJuThr1N6IuBS4FEBS/wSeh5lZac2cQrHEDIQ30SGjs0jqA2ZFxFNTHYuZTX9Vz8Vlx5k9UtJba+5/E3imGPT2BTkHNDMrIwKGQqWW6UrS3pLeUbfu48BTwBJJv5C07pQEZ2ZdoRNycdmW2SOBvwWQ9GrgHcC7gLcCXwLe1JLomqGnfNP44OzyZQfWy7vA+cXr5g1Z+ZIZ5bvB3Tqw9viFavT1ZF6c3crPZ85Z3NxpFAcH88rnTAHZyqkoqyZnitqM71sZzTq11cE+Dvx85I6knYHPAd8EbgY+Bnyi+FtNEVlT1GZp6fS0tHaq6CZO/fwsVcpPLXwNlbvr3I9hRvkVg3nT2S7LnM726cGZpcv2K3fe3vFVPReXfTU3A+4qbv818B8R8WNJ1wO/aklkZtbVRmad6XIvJlVoR7wd+E1EfABA0r3AP1PlyqyZdbROyMVlq9pPABsVt/cBflncHiBdZWZm1nTDqNQyja3L6sPR7Ab8oub+VaTGBjOzlql6Li7bMnsx6cqyPwDPZ9VprxeyqsXWzKxpAhgczjt1Nw09ADwPuFfSTGAH4JM129di9SnGzcyaqhNycdmW2cOBXwMbAm+LiL8U63cEftiKwMysy5Uc17Dqp78m6efAF4thEU8Cnmb1rl3bkcb8NjNrjQ7IxTnjzH64wfpPNT0iMzOKgbqndxeCMo4HzgP+hzSCwfsiYkXN9r8FLpmKwMysO3RCLs67nA6Q9FfAjNp1EfGnpkVkZlaY5q2u44qIR4BXS1oHeCoi6i9Tfjupkmtm1jJVz8WlKrNFIv0qaUiuGQ2KVLszhZl1nJEpFA0i4vFR1v+l0Xozs2bphFxcts/sKcBLgL8BlpHGmP0YsBh4Z0siM7OuV/V+WmZm3aDqubhsN4PXAwdGxK8kDQFXR8SPJD0A/B1wbssiNLOu1AljG5qZTXedkIvLtsyuC9xT3H4c2KC4fSXwiibHZGYGVH9sw3aQtK6kN0p6hSTVbVtD0vGjPdbMrBmqnovLVmb/CDy3uH0zcECRVN8CuM+WmTVfVP/UVqtJeiEp5/4X8H/AVZK2qCmyJuBRZcysdTogF5ftZvBt0niGlwNfAH4KHEGqDB/VisCaIXrE8IzyAzYsX6v8G9G/4dKsWHZZ849Z5TfqnVO67HUr+rP2nTuH9Myh8hNgK6MsAEMZk1/nlAUidz743Hnbu4XKfy9yvm/j6YSLDtrg86QzYO8B1ga+Avxa0p4RcfuURtYqPRlzwEdmvmmhGM6LpaevdZ/tyHgJgbzXXLk7b53s9JBZXhkHyP0krhjOy5XPDJX/ne/rmZkZzdg6IReXHWf2X2puXyppG2An4PaIuL5VwZlZ9wrE4HB1fjinyC7AnhHxNGnChHdIOhW4XNKepG5fZmYt0wm5eELNKMW4sh5b1sxaKireGtAGM6lr9ImIo4tuXpeTRpYxM2upqufi0pVZSS8H9gY2oq6vbUQcWeLxZwFvAh6KiBc12L4ecBZpHvJlwN9GxA3Fto8Ch5KS+vXAIRGxrGzsZtaZpvvFXSXcSjoLdlPtyoj4qKQeUl/aLJI2B74DbEzKqWdExFfqyrwb+AfSidkngQ9FxHXFtnWBM4EXFY//24i4MjcOM+scVc/FpdqNJR1D6rd1MLA98OKa5VkV01F8G9h3jO3/CFwbEdsB7yX1DUPSZsCRwE5FJbgXOKDkMc2sQ0UHXHTQBucDBzbaEBFHAd8juycgg8DfR8QCUjeGwyUtqCtzF7B7RLwY+CxwRs22rwC/iIhtSOOP35x5fDPrIJ2Qi8u2zB4FHBkRp030QBFxhaT5YxRZQLq4jIi4RdJ8SRvXxDlb0gAwB7h/onGYWeeo+qmtVouIz5MuAhtt++HA4Zn7fAB4oLj9pKSbgc2oaf2NiN/UPOS3wDxYORvkq0kNG0TECmBFzvHNrPNUPReX7dG7NnBhKwMBriMN9YWknYEtgHkRcR9pBrI/kRLw4xFx8Wg7kXSYpIWSFg4M5o04YGZVUq4lYJq3zLZU0cCwA/C7MYq9H/h5cXtL4GHgW5KukXSmpDUa7HdlHl7B8maHbWZtVf1cXLYy+0PG7iLQDF8A1pV0LfBh4BpgqOhLuz8piW4KrCHpoNF2EhFnRMROEbFTf1/54a3MrHoiVGqxfJLWBP4T+EhEPDFKmT1Jldl/KFb1ATsCX4uIHUgjLHy8/nG1eXgGzR0myMzar+q5eNRuBpKOrrl7L/AZSbsBi4CB2rIRcepkAymS6SHFsUXqs3Un8Drgroh4uNh2HmnWse9N9phmVl2dMLZhu0h6DnBvxOoDqxa5cvNihJmc/fWTKrLfj4jzRimzHelCr9dHxKPF6sXA4ogYack9lwaVWTObPjohF4/VZ/bDdfefIlUi66evDWDSldniCtmlRR+sQ4ErIuIJSX8CdpE0B3iGNKLCwskez8wqLio1Jv5UuwvYBHiobv36xbbSM6EUFeBvAjeP1hBRVJ7PA94TEbeNrI+IP0u6V9ILIuJWUj6+qdE+zGya6IBcPGplNiK2bOaBJP0Q2AOYK2kxaQrG/uJYXwe2Bc6WFMCNpFNbRMTvJJ0L/IF0Fe41rH5lrZlNU1UfDqaNRONJhtYkDWWYYzfSjGLXF926II0m8xxYmY+PBzYA/i3VfRmMiJ2Ksh8Gvi9pBuns2SGZxzezDlP1XJw9aULRz4qIeCrncRHRcHiZmu1XAluPsu1TeP5xs64SVP8K2laT9NXiZgCfl1R7VWsvsDNwbc4+I+L/GGc4r4g4lHSGrNG2a0lj35pZF+iEXJwzacJHgKNJQ7gg6X5S94Iv1/fjqgyJ4Vnl6+vL1y//Zs2f+5esUBbM+HNW+V6Vv3jtvoH1sva9bOmMrPJzMgbeUeb85FnnLnI/ZkNDmeWH88pnKFq3SqvUFypjLvac71uJAzM0XO0E2gYvLv6KdPaq9tu4gnTG6pR2B5VFgp6MqTAzvivZ36uMz3J6QGYOqYjc14Xe0r1UUG/eaxh95fcNED0Zsee+/7lvf0/rMnFuH9ScltEVw83Mw9AJubjUM5b0ReAw4GTS5AkAu5JORW0CHNuS6Mysq1W9NaDVImJPAEnfAo4abdQBM7NWqnouLlt9PxQ4NCLOrVl3qaRbgX/HlVkza7KI6ifQdokI90s1synRCbk4py160SjrMhvuzczKqfpwMO0k6Z2k0QM2oi7vRsR+UxKUmXWFqufishXR79B4ysQPAd9tXjhmZqtElFumO0knk8bWng8sAR6tW8zMWqbqubhsy+xM4F2SXkeapxvg5aQZub5fc8UtEXFkc0M0s25V9VNbbfRe4MC6rl5mZm1R9VxctjK7DemqWYAtir9/LpZta8p1QRuJmbVD4Klqa/SQOQSXmVkzdEIuLlWZHbmi1sysnfzf8UpnAAcBn57iOMysC1U9Fzd7MDIzs+bogCto22hdUlevfUgX3g7UbnT3LjNrmQ7Ixa7Mmll1Vb05oH0WsKqbwTZ12/wqmVlrVTzLuDJrZpU1XPFZZ9rFXb3MbCpVPRdP68ps9IihOeWf4rINyv/r8YJ1HsyKZcPevH9rHh9+pnTZu5ZvmLXv4af7s8r3rigfu3KnhB3OKJ87PW3uOCFRPpaqzuDcCsqYjjLn+zaeTpgP3FqgS75brcwh2dPZ5u28MuXzp6fNK58xg2y23HFbB4bL5+GeJjejdkIu9oQHZlZNAYTKLV1A0usl/UzSzZI2L9YdKmnvqY7NzKaxDsjFk6rMSuqR9JxmBWNmVqvqA3W3i6R3Az8GbiNNnDByeqUXTyduZi1W9Vw8ZmVW0ixJX5f0sKTbJB1VV2RD4K7WhWdmXS1KLtPfscAHIuKjwGDN+t8C209JRGbWPSqei8fr4HY88Kbi7zrAP0l6GfDeiJUdDLvjHJ+ZtVn1B+puo62AKxusfwpYu82xmFlXqX4uHq+bwTtJrQFfi4gvADsBOwI/kDTy2O5oFzGz9qt4a0Ab3Q9s3WD9q4E/tjkWM+s2Fc/F41VmNwFuHrkTEfcAewIvBs5hVb8tM7PmKgbqLrN0gTOAr0rarbi/uaT3AV8EvjZ1YZnZtNcBuXi8yuwDwPNrV0TEg8DepArtd1oUl5lZU1sDJO0r6VZJd0j6+Chl3iHpJkk3SvpBE55BU0TEF4HzgEuANYDLgK8DX4+I06cyNjPrAhXPxeP1mb0MeBfwP7UrI+LPkvYC/rdc6GZmE9Gc//Ql9QKnA/sAi4GrJF0QETfVlNkKOA7YLSIek7RRUw7eJBHxCUknkmYD6wFuioinpjgsM+sK1c7F41VmP8uzp04EICIekLQ78NqSz8HMLE/mHBxj2Bm4IyLuBJB0DrA/cFNNmQ8Ap0fEYwAR8VDTjt4Ekt5JOiu2EcVZtZHB8SNiv6mLzMymvYrn4jG7GUTEPRFx0RjbH4iIs0sEb2aWJ2+g7rmSFtYsh9XtbTPg3pr7i4t1tbYGtpb0a0m/lbRvy55bJkknA98jjTG7BHi0bjEza40OyMXTejpbM+tsGYNwPxIRO03ycH2kIbD2AOYBV0h6cUQsmeR+m+G9wIERce5UB2Jm3afquXhaV2ajFwbWLD+f8eC6Q6XLbjZzyQQiKm/x4PhlRty9dIOsffc+lTfxW+/y8p9iDeadi9BQ+fLZc5kPlX8/ARiu0BhPyniPIvN55uwboK98msj5vpXSvLfkPmDzmvvzinW1FgO/i4gB4C5Jt5ES6lVNi2LieoBrpzqICYmA4eado1xt1xn5Iz2gNXFMaN8tzDeR+RVXRq6MFr2XK/ffW75v5nBmusl9Xegt/x719eS9Lrnlc/SoBZ+tiufiSU1na2bWUs2bD/wqYCtJW0qaARwAXFBX5ieklgAkzSWd6rqzac9lcs4ADprqIMysS1U8F7etZVbS5qShvDYm1fHPiIiv1JVZDzgLeB6wDPjbiLih2PZR4NDisdcDh0TEsnbFb2bt16wGhogYlHQEcBHQC5wVETdKOgFYGBEXFNteK+kmYAj4WERUpT/qusC7JO0DLAIGajdGxJFld1QyF69D6qP7HNLvxCkR8a1i20nAG4uin42IH03kCZlZ56h6Li5VmZV0KfCW+v4KktYGfhIRe5XYzSDw9xHxB0lrAVdLuqR2OAbgH4FrI+LNkrYhDd+wt6TNgCOBBRHxjKQfk2rz3y4Tv5l1oCbPKBMRFwIX1q07vuZ2AEcXS9UsYFU3g/oRZnJfpTK5+HDS0F9/LWlD4FZJ3ycNp7MjsD0wE7hc0s8j4onMGMysU3RALi7bMrsHMKPB+lnAq8rsICIeIE3CQEQ8Kelm0hVstQl0AfCFoswtkuZL2rgm1tmSBoA5pOkdzWzaKn3aatqLiD2buK8yuTiAtZTG/loT+AupErwAuCIiBoFBSYuAfYEfNys+M6ua6ufiMSuzknasubudpL/U3O8FXsezO+6OS9J8YAfgd3WbrgPeAvxK0s7AFsC8iLha0inAn4BngIsj4uLc45pZh6nQNXnT0Ri5+DRSP7b7gbWAd0bEsKTrgE9J+hKpUWFPVq8Em9l0VPFcPF7L7EJWNTA3qjw+A3w454CS1gT+E/hIg1NTXwC+IulaUr/Ya4Choi/t/sCWpDEW/0PSQRHxvQb7Pww4DGDm7HVzQjOzqql4Am2n4izV4aTW0SBVIv+tmGJ8IvsbKxe/jtStYS/SNQyXSPpVRFws6WXAb4CHgStJfdrq970yD8/SGhMJz8yqpOK5eLzRDLYkJTKRZm3YsmbZDFg7Is4qezBJ/aTk+f2IOK9+e0Q8ERGHRMT2pHEVNyRdwfYa4K6IeLgYquE84BWNjhERZ0TEThGxU99MJ1GzjhXAsMot05yk3YA7SNOLP0O6QPbdwO2Sdp3A/sbMxcAhwHmR3AHcRdFXNyJOjIjtI2If0m/DbfUPrs3DM5iZG56ZVUkH5OIxW2Yj4p7i5qSH8Cr6Xn0TuDkiTh2lzLrA0ohYQRq54IqIeELSn4BdJM0hJfK9Sa3GZjaNtWK4xA51CvBD4IMRaUBTST3A14EvMco/942UycWkLl17k7p8bQy8ALizmFd93Yh4VNJ2wHY0PmtnZtNI1XNx6aG5JM0DXk3NvOAjxkiItXYD3gNcX3QjgDR6wXOKfXwd2BY4W1IANwLvL7b9TtK5wB9IFyFcQxp30cyms4on0DbaHjh4pCILUPRhPZWUD3OUycWfBb4t6XpS6+s/RMQjkmaRKrgATwAHFReDmdl0VvFcXHZorneTxn8dJPWTqn1aAYxbmY2I/yMlxbHKXEkaHLfRtk8BnyoTr5nZNPM4qXvXrXXrR64jKK1kLr4feG2D9ctIfXbNzCqjbMvsCaRTWZ+MyJ07cwr1iMHZ5XtIaNbA+IUK/cp7Gf6SOXPd7QMbli5739PrZO277+nM6WxXlG940UDuFLIZL0zu9LSZsqfLzdFTocn2ejL7NfWXn1sl5/tWRtVPbbXROcA3JR1LuvgKUgvrSaTuB5UVtPC7lTuFbCu/47laObXucO58ti3Mwy18zSMzl0V/3v7VX/51mdmfd4JiTt+KrPJr9C0vH0tP80+WVD0Xl/2V2hg4s6MqsmbW+So+tmEbHUtqTT2LVXl7APga8PGpCsrMukTFc3HZyuyFwMupzjzlZjbdNXnWmU5WXBR7lKTjSCPMAPwxIpZOYVhm1g06IBeXrcxeApwk6YWk8V/r5wVvNLSLmdnkVDyBtltELJV018jtqY7HzLpExXNx2crsvxd//7HBtiDNBmZm1lRV76fVTpI+QpqrfLPi/v2ki2+/HC3t8G1m3a7qubhUZTYiKnT1ipl1jYon0HaR9EXSjFonk2bdAtgVOB7YhNSn1sysNSqei8tfpmxm1kaKvIusp7lDgUMj4tyadZdKupV05syVWTNriU7IxaVaXJX8P0k3Sloq6bnF+o9LekdrQzSzrhUqt3SHRaOs85kzM2utiufisknwKOCfSLNu1UZ7H3BEs4MyMwNWXUU73jL9fQc4vMH6DwHfbXMsZtZtKp6Ly3Yz+CDwgYj4maR/rln/B+CFzQ/LzKz6Fx200UzgXZJeB/y2WPdyYFPg+5K+OlIwIo6cgvjMbBqrei4uW5ndArihwfoBYHbzwjEzq1HxBNpG25AaDyDlY4A/F8u2NeX8iplZ81U8s5StzN4J7AjcU7f+DcBNTY3IzAwgqt8a0C4RsedUx2BmXaoDcnHZyuwpwGmS5pD6zO4q6T2kK2j/tlXBTVYAOYOKxVD5zssPDqydFcudA+vnlV++Uemyjz49J2vffc9kFadnRflPsQYzL3kczJghOXcozeEKffuU1zFeGXOO507xrt68YaGjr3z5pg/iV6G30KonqvQdb7Gc56rMkd9zhilWbh4eyk1Q5YtG5vMcmpEXe9+sgfELFdaZuSxr3xvNfCqr/AYzypfvaUXirPhXrew4s9+S1Ad8DphDuuDgfuDIiPhRC+Mzs25W8QTaTpI2BnYDNqLu4t2I+LcpCcrMukPFc3HpcWYj4hvANyTNBXoi4qHWhWVmVv1TW+0i6SDgTFK71WOs/tMSgCuzZtYyVc/F2ZMmRMQjrQjEzMxGdSLwReCEiBic6mDMzKqkVGVW0vqkZLo3jU9x5XUgNTMbTwfMOtNGawPfdkXWzNquA3Jx2ZbZbwI7kCZNuJ/K954ws2nBmWbE94E3Av861YGYWReqeC4uW5ndG9gnIn7XymDMzFZT8QTaRkcDP5G0N3A9aYzvlSLihCmJysy6Q8VzcdnK7ENA3jgSZmaTIKp/0UEb/R2wL/AI8HyefQGYK7Nm1hKdkIvLVmY/AZwg6X0R4UqtmbVHxRNoG30S+PuI+JepDsTMulDFc3HZyuw/AfOBhyTdw7NPcW3X5LjMrNt1wKwzbdQLXDDVQZhZF+qAXFy2MntuS6MwM2uk4gm0jb4FvBt3JzCzqVDxXFx2BrDPtDoQM7NnqXgCbaM5wKGSXgcs4tlnx46ckqjMrDtUPBdnTZogaS9gAelp3RgRl7ciqGZRQE/GqIx6uvxEz7c/uWFWLBv3P5FV/s5nyu//maUzs/Y9Z3lWcXpXZAwwNziUt/OhjPI5ZcmbbxxAypgUvCejbNp5VvFQz/iFVsaSOUF5b2b5jNhzvm+lDl3xBNpG2wLXFLe3qdvWta+SMr+HUfGxMseS+1xbZjjz45aZh3MMZ6ay4f688mvMGhi/UGGTOXm/8ZvP+ktW+bl9T5Yu29uCQWGrnovLTpqwGXA+8FLSOLMAm0paCLw5Iu4f9cFmZhNV8QTaLhGx51THYGZdrOK5uGzzz1eBIeD5EbF5RGwObFWs+2qZHUiaJen3kq6TdKOkZ3VdkLSFpF9KWiTpcknzivV7Srq2Zlkm6W9Kxm5mnaiYdabM0g0kbSzpBEnnSvoPSZ+WtNEE9lMmFx8s6eGanHtosX4LSX8o1t0o6YPNeG5mVmEdkIvLdjPYB9gjIu4aWRERd0o6EvhlyX0sB/aKiKck9QP/J+nnEfHbmjKnAN+JiLOLLg2fB94TEZcB28PKqXXvAC4ueVwz61QVbw1oF0m7Ab8AHgSuLFYfBBwt6XURceWoD362MrkY4EcRcUTdugeAXSNiuaQ1gRskXeCzc2bTXMVzcU6f2UZPpfTTi9SBcWSM2v5iqX/8AtJMNwCXAT9psKu3AT+PiKVlj21mnanq/bTa6BTgh8AHI1LPT0k9wNeBLwGvKLujkrl4tMeuqLk7k/Jn98ysg1U9F5dNRL8E/lXS5iMrJD0H+DLlW2aR1CvpWtKMYpc0mB73OuAtxe03A2tJ2qCuzAGkpG5m012UXKa/7YEvjVRkAYrbpwI75O6sRC4GeGvR5evcuty/uaRFwL3ASW6VNesCFc/FZSuzRwJrAHdKuqeYOOGPxbrSQ8JExFBEbA/MA3aW9KK6IscAu0u6BtgduI/ULxcASZsALwYuGu0Ykg6TtFDSwoHlT5cNzcyqpmzy7I7K7OPAlg3Wbwksyd1ZiVz838D8YkKcS4Czax57b7H++cD7JG1cv//V8nAsyw3PzKqkA3Jx2XFm75W0I/AaVg0Lc3NE/M9EDhoRSyRdRppr/Iaa9fdTtMwW/bHeGhFLah76DuD8iBh1vIyIOAM4A2DN9Tfvjp85s2lIxWIAnAN8U9KxwG+KdbsBJzGJM1Vj5OJHa4qdCXyxwWPvl3QD8CrqJtapzcNr92zgPGzWwTohF5fuM1v0s7qkWLJJ2hAYKJLnbNJFZSfVlZkL/KU4fXYccFbdbg4s1ptZN3A1aMSxpN+Ts1iVtweArwEfz9lRyVy8SUQ8UNzdD7i5WD8PeDQinpG0HvBK4F8m9pTMrGNUPBeXrswWQ2EdTbpIC1JyOzUizi+5i02AsyX1kro3/DgifirpBGBhRFwA7AF8XlIAVwCH1xx/PrA58L9lYzazzlb1iw7apbjw6ihJxwHPK1b/cYIXwpbJxUdK2g8YBP4CHFw8dlvgS0WOFnBKRFw/4SdmZh2h6rm47KQJfw98DvgO8O1i9a7ADyR9MiJOGW8fEbGIBhcqRMTxNbfPpe50Vc22u4HNysRrZtNExRNouxWV10lVHkvm4uNocBYsIi4BtpvM8c2sA1U8F5dtmT0GOCIivlGz7ixJvwdOIA0bUz0R9C4vP4rvjCXl58a7e8n6WaGsN+OZrPKPrZhduuzgsqxZiekpP0MfABrK+BTnTjk7lDHKcuY0ilnT00LeNK+9mSMS5U6tO5j3nmbtO/d1yZDzfSuliQlU0r7AV4Be4MyI+MIo5d5K+qf6ZRGxsHkR5JP0elJXgu0i4om6beuQRoD5QFHJrCTRus9c1rTPkD2tdN6+c2Np4ahmmVPftjIntHI628idznZGXixrzio/9/smMx/P2vcWMx7JKv9XfeX3368mzysOlc/FZb9Na5LGfa13WbHNzKy5mjjrTHFK/XTg9aSuUgdKWtCg3FrAUUCjoaqmwhHAyfUVWYCIeJzU1/Uj7Q7KzLpIB+TispXZn5AmK6j3VuCCkvswM8uiKLeUsDNwR0TcWfQ/PQfYv0G5z5IqiFUZT2o7YKxRYy4FXtKmWMysS1U9F5c9l3kH8HFJe7JqKsVdiuVUSSOzdhERp5bcp5nZ2Mqf2porqfY01BnF8FAjNiMN8j9iMfDy2h0Uww9uHhE/k/SxCUTbChsCY7V3BFA/sYyZWXNVPBeXrcweDDwGbF0sIx4DDqm5H6QZaczMJi3jCtpHImKnCR8nTQ17Kquu2q+KxaTW2dtH2b4daXIZM7OWqXouLjtpQqOZZ8zMWqe5M8rcRxrab8Q8Vq8ErgW8CLi8uBjmr4ALJO03xReB/Qz4rKQLI2K1q0glzSFdgPuzKYnMzLpDB+Ti1l0ybWY2Wc1LoFcBW0nakpQ4DwDetfIw6WKquSP3JV0OHDPVoxkAJ5KuV7hN0mnALcX6bUkXh4k0bKKZWetUPBfnTJrwZmBPYCPqLhyLiHeU3Y+ZWRmieQN1R8SgpCOAi0jDwZwVETfWTRRQORHxkKRXkIbn+hyrZpUM0nM5PCIenKr4zGz664RcXHbShC8BHwZ+DTwI5A0mamY2EU0c2zAiLgQurFt3/Chl92jekScnIu4B3lBMH/t80m/L7RHx2NRGZmZdo+K5uGzL7PuAt0fEf5Usb2Y2aWrhgOtVJ2nLiLhr5H5Reb1qlLIC5kXEvY22m5lNRtVzcdlxZpeyqq+WmVnrRcYyPV0p6ZuSdh2tgKT1JH0IuInGYzWamU1OB+Tisi2zXwCOlfR3EdGCedLMzJ6tWf20OtQ2wCeAn0kaBq4G7icNIr4eafacbYHfAx+JiIumKlAzm96qnovLVma/Afw1cJ+k24CB2o0RsVezA2sGDUPvsvJzxc94vPzgDkseWyMrlrvnrJ9VfmAoY9Lpgcx5tcu/JEDe6QUN5e08IjOYHJnzk9NX/v1Xb9686pF5ikYZsTCc+Rrmvi5D5bvI53zfyigzPeJ0FRFLgI9JOh54I/BKYAtgNvAIcDZwUUTcMGVBliFBb0Y+y5F76lN539u8XWd+r3Jl7L8Y0ihj3xmvS+7zzIwlMspH7tvZl/d5mdM/MH6hwnr9T2ft+6/6Hs8qv2nfk6XLzmpBzbPqubjsL+bXSYn0F6QLwCpeRzezacGZhmJ82XOLxcys/Sqei8tWZt8JvDkiLmllMGZmK5Wf69vMzFqlA3Jx2Ub6h/GUiWbWbhW/6GAqSJotabMG6184FfGYWReoeC4uW5n9FHCCpDVbGYyZ2YiRgbrLLN1C0tuA20kXhS2S9PKazd+dorDMbBrrhFxctpvBx4D5wIOS/sSzLwDbrslxmZnlX+Az/f0T8NKIeFDSS4GzJX0uIn7AqtnBzMyaq+K5uGxl1hcemFnbdVOra0n9I9PXRsTVkl4NnC/p+XRdhwsza5eq5+JSldmI+EyrAzEzW00X9oct4SFJ20XEIoCI+IukfUjDdPkMmZk1Xwfk4ozBLEHSXqSBugO4MSIub0VQZmZQ/bENp8B7gNUmromIFcCBkk6bmpDMbLqrei4uVZktrpw9H3gpaQYagE0lLSQN2XX/qA82M5uoircGtFtELB5j26/bGYuZdZGK5+KyLbNfBYaA50fEXQCSngt8r9j2ttaEZ2ZdK0DDFc+gbSLprFE2BWl62zuAH7lhwcyargNycdnK7D7AHiMVWYCIuFPSkcAvWxKZmXW9ql900EYbAq8iTUY9Mn3ti0gjGFwNvIU0fOKrIuLaKYnQzKatqufinD6zjZ5KpZ+ehoO+ZeXnle9/MuPpLJmRFcvD66yRVb6vJ6ODSuTOlZ1XvDJy53fvzZu4W30Z+8+ZyxzQcF6Ho8h5rpmxkPkftgbLf4dyvm+lVDrDtNWvgaeA90fEUgBJc4BvANcBbwC+A3wJ2HuqgmxIoNzvblm5wwUNNfnzWUuZOSEzP2XJzQnK+FHIKTuR8ln7zisevXmfl5m9g+MXKqzVsyxr3+v2PJNVfv2Mt3SO8uonpVQ8F5d9eX4J/KukzUdWSHoO8GXcMmtmLdAJA3W30VHACSMVWYDi9onAR4uLwE4Ctp+a8MxsuuqEXFy2MnsksAZwp6R7JN0D/LFYd2TOASX1SrpG0k8bbNtC0i+LmW0ulzSvZttzJF0s6WZJN0man3NcM+swEeWX6W9NYJMG6/+q2AbwBBln28bJxa+W9AdJg8WsY7XbnIvNukkH5OKy48zeK2lH4DXANsXqmyPifyZwzKOAm4G1G2w7BfhORJxdDAP2edJQNJBOoZ0YEZcU0+pWfKAIM5usLml1LeN84JuSjgWuKta9DPgicF5xf2fgtox9jpWL/wQcDBzTYJtzsVmXqXouLv1ffEQEcEmxTEjR0vpG0qmxoxsUWVCz/jLgJ8XjFgB9EXFJEctTE43BzDpIxRNoG30QOJU0gsxI3h4EzmJVhfNm4ANldjZeLo6Iu4tyw3WPcy4260YVz8VjdjOQ9HpJd0t61n/uktYptu2TcbwvA8cy+n/y15GuygV4M7CWpA2ArYElks4rToudLKlFVxSYWVVUvZ9Wu0TE0oj4ILA+sEOxrB8RH4qIp4sy12aMZPBlxs7Fo3EuNutCVc/F4/WZPQI4OSKeqN8QEY+TLjj4SJkDSXoT8FBEXD1GsWOA3SVdA+wO3Eca37aPNCzNMaRTa88lnQJrdJzDJC2UtHDFwNNlQjOzKgrSyAtlli4REU9HxKJimVCCK5mLR1MqF6+Wh4fzrvI2s4rpgFw8XmV2O2CsfrGXAi8peazdgP0k3Q2cA+wl6Xu1BSLi/oh4S0TsAHyiWLcEWAxcGxF3RsQgqfvBjo0OEhFnRMROEbHTjP684bDMrGKi5NIFJG0s6QRJ50r6D0mfkbTxBHY1bi4eQ6lcvFoe7pk1gRDNrFIqnovHq8xuyNinoQLYoMyBIuK4iJgXEfOBA4BLI+Kg2jKS5korB+s7jtQfDNIFD+tK2rC4vxdwU5njmlnn0nCUWqY7SbuRZvl6F/AMadavdwO3S9o1Z19lcvEYnIvNulDVc/F4ldnFpNbZ0WxH6gowYUVLw37F3T2AWyXdBmxMujiBiBgindb6paTrScOefWMyxzWz6qt6P602OgX4IbB1RLwnIt5D6r96DmmihEmrzcWSXiZpMfB24N8l3QjOxWbdquq5eLzRDH4GfFbShRGx2nQVxewzJxRlskTE5cDlxe3ja9afC5w7ymMuYeyKtZlNJ13UhaCE7YGDI2LlmbKIGJZ0KnDNRHc6Ri6+Cpg3ymOci826SQfk4vEqsycCbwNuk3QacEuxflvSxWECPte68CYpoGd5xnS2S8u/W/1P5c2jt3TpzKzys2YNlC+c+e/QcM4kxsBwzrSL2VMdZuw785pp9WU+0ZwpN3OfZ+Z0tkSFhu4cKh9LzvdtPGnWmYpn0PZ5HNgSuLVu/ZbAkrZHk0OC/ozvYs6pytzpaTOnnM3Sk5kTcqeczZGbn3JiaeVrCFlT1EYrp8oFejJ+W3PKAvQrL8fPyhg0ZKYyf/vG0Qm5eMxnHBEPSXoF8DVSpXXkkxPARcDhEfFga0M0s65VoTr9FDuHVZMm/KZYtxtpRJkfTllUZtYdKp6Lx62+R8Q9wBskrQc8n1ShvT0iHmt1cGbW3areGtBGx5Jy71mkvC1gBamh4eNTGJeZdYGq5+KcGcAeY9U0imZmrdUB/bTaJSJWAEdJOg54XrH6jxGxdArDMrNu0AG5uLkdK8zMmiag4q0BrSTpghJlAIiI/cYpamY2QdXPxa7MmllldcmwW6N5dKoDMDOD6udiV2bNrLoq3hrQShFxyFTHYGYGVD4XuzJrZtUUoKFqJ1Azs2mvA3KxK7NmVl3Vzp9mZt2h4rnYlVkzq6yqDwdjZtYNqp6LXZk1s+qqeAI1M+sKFc/FrsyaWTUFlZ91xsxs2uuAXDy9K7MRaKD83N19y8r/59G7NG9+6hXL8l7q4RmD5Qv35/3HNDwzqzjD/eXnv47evNdFWeUz5wTvy/x4t3Ke79z/anPmpx/OyzKRGYsy9p/zfRt3X0TlT21ZGcr7Lg6V/wypt/x89QD05n0+c74rys0frcw3PZl5OCeWngo9T2uoV5m/lePohFw8vSuzZtbZKp5Azcy6QsVzsSuzZlZdFU+gZmZdoeK52JVZM6umDuinZWY27XVALm5uxwozsyZSRKml1L6kfSXdKukOSR9vsP1oSTdJWiTpl5K2aPoTMjPrQFXPxa7MmllFRbq4rcwyDkm9wOnA64EFwIGSFtQVuwbYKSK2A84FvtjkJ2Rm1oGqn4tdmTWzagpSP60yy/h2Bu6IiDsjYgVwDrD/aoeLuCwilhZ3fwvMa+bTMTPrSB2Qi12ZNbPqGi65wFxJC2uWw+r2tBlwb839xcW60bwf+HkznoKZWccrn4vH05Jc7AvAzKyyMsY2fCQidmrKMaWDgJ2A3ZuxPzOzTpeRi+dKWlhz/4yIOGNCx8zIxa7Mmll1NW84mPuAzWvuzyvWrUbSa4BPALtHxPJmHdzMrKM1r2GhJbnYlVkzq6Ygbya0sV0FbCVpS1LiPAB4V20BSTsA/w7sGxEPNevAZmYdrQNysSuzZlZRpS8oGH9PEYOSjgAuAnqBsyLiRkknAAsj4gLgZGBN4D+K6T3/FBH7NSUAM7OOVf1cPK0rs4q8ueJ7Bsq/Wb0rMoMZzJufWsqIZWbefONDM7KKE30ZsfdlzpWeM2d7rt4WXt84lDeCdGSXL/+e5swfD6ASw6esJiOWnO9bKU2cdSYiLgQurFt3fM3t1zTtYLaKQD3lv4tZ73hv5mc5Iw6YwHclR2YsVVFULkqLnszyecVbanC4/Hs0nBn4QOS9/0NTPWtBxXPxtK7MmlmHq/gUimZmXaHiubitlVlJdwNPAkPAYH0nYUnrAWcBzwOWAX8bETeUeayZTTPN7adldYrByxcC90XEm+q2/QuwZ3F3DrBRRKxbbDsJeGOx7bMR8aP2RGxmU6IDcvFUtMzuGRGPjLLtH4FrI+LNkrYhzRKxd8nHmtm0EjDc5G4LVuso4GZg7foNEfHRkduSPgzsUNx+I7AjsD0wE7hc0s8j4ol2BGxmU6H6ubhqnXYWAJcCRMQtwHxJG09tSGY2JUZaA8oslkXSPFLr6pklih8I/LC4vQC4IiIGI+JpYBGwb2uiNLNK6IBc3O7KbAAXS7q6wQw9ANcBbwGQtDOwBaumMRvvsWY23TRvCkVb3ZeBYxlnzh5JWwBbUjQykHL0vpLmSJpL6oqw+WiPN7NpouK5uN3dDF4ZEfdJ2gi4RNItEXFFzfYvAF+RdC1wPXANqY9smccCUFR0DwOY1f+ss2dm1klcUW06SW8CHoqIqyXtMU7xA4BzI2IIICIulvQy4DfAw8CVrMrRtcdYlYd712xe8GY2NSqei9vaMhsR9xV/HwLOB3au2/5ERBwSEdsD7wU2BO4s89iafZwRETtFxE4z+tZo1VMxs5Yr2RJQ8SRbQbsB+xUX1Z4D7CXpe6OUPYBVXQwAiIgTI2L7iNgHEHBb/YNWy8M9s5sbvZm1WfVzcdsqs5LWkLTWyG3gtcANdWXWlTQyCuqhpL5ZT5R5rJlNMwEMD5dbrLSIOC4i5kXEfFJl9dKIOKi+XHER7nqk1teRdb2SNihubwdsB1zclsDNbGp0QC5uZzeDjYHziwGX+4AfRMQvJH0QICK+DmwLnK00Y8CNwPvHemwbYzezqeBW17apm4EHUkX3nFh9Vo5+4FdFLn4COCgiBtsbqZm1XcVzcdsqsxFxJ/CSBuu/XnP7SmDrso81s2mu4gm000XE5cDlxe3j67Z9ukH5ZaQRDcysm1Q8F0/vGcAi0FD5NyBnOtueFrdFzOjLmM505kDWvodmzcoqP9yfMU1f7hSNOdPf5n6ZMqddzNp/biyDmR+YnP3nDoeSGXvOVLw537cSR/awW9OCoLf89zznW5s7VWq2Lplylla+jrmx5Ow6Nw9nFs+ZonYg8qpTKzJ7eQ5knAAZiGaPCVv9XDy9K7Nm1rkCItwf1sxsSnVALnZl1syqK6NV2MzMWqTiudiVWTOrpgiPVGBmNtU6IBe7Mmtm1VXxiw7MzLpCxXOxK7NmVllR8dYAM7NuUPVc7MqsmVWUZ/cyM5t61c/FrsyaWTUFlR8Oxsxs2uuAXOzKrJlVV8WHgzEz6woVz8WuzJpZJQUQFW8NMDOb7johF7sya2bVFFH51gAzs2mvA3KxK7NmVllVbw0wM+sGVc/FiopfoTYZkh4G7qlbPRd4ZArCacSxNOZYGpuOsWwRERs22iDpF8VxyngkIvZtQjzWZKPkYZien+dmcCyNOZbGmhHLqHkYOiMXT+vKbCOSFkbETlMdBziW0TiWxhyLTSdV+gw5lsYcS2OOpXp6pjoAMzMzM7OJcmXWzMzMzDpWN1Zmz5jqAGo4lsYcS2OOxaaTKn2GHEtjjqUxx1IxXddn1szMzMymj25smTUzMzOzacKVWTMzMzPrWNO2MitpX0m3SrpD0scbbJ8p6UfF9t9Jmt/m428h6ZeSFkm6XNK8mm0nSbqhWN45yTjOkvSQpBtG2b6epPOLOH4v6UU12z4q6cYijh9KmjXJWDaXdJmkm4r9HjVV8UiaVez/umKfn2lQpuF7JGlPSdfWLMsk/c1EYyn22SvpGkk/LRtHse05ki6WdHPxus6fTBzFPu+WdH3x3BY22D7WezTmY627lMg/kvTVIk8ukrRjO49flNmj+LzeKOl/i3Xj5ocJxFIm/727eB2ul/QbSS+p2baupHMl3VJ833dtcSzrSPrvmtfgkJptzfyNKpOLD5b0cE3OPbRYv4WkP9S8fx+cTCzFPsfKxa8ujjco6W1121qRi8eK5V9qXo/bJC2p2da096djRMS0W4Be4I/Ac4EZwHXAgroy/w/4enH7AOBHbT7+fwDvK27vBXy3uP1G4BLS7GxrAFcBa08illcDOwI3jLL9ZOBTxe1tgF8WtzcD7gJmF/d/DBw8yddlE2DH4vZawG0NXpe2xAMIWLO43Q/8DtilzHtUV2Z94C/AnEm+NkcDPwB+2mDbqHEAlwP7FLfXnGwcxX7uBuaOsb3he1TmsV66aymRf94A/Lz4Pu4C/K7Nx18XuAl4TnF/o+LvuPlhArGUyX+vANYrbr++9vUAzgYOLW7PANZtcSz/CJxU3N6wyHMzaP5vVJlcfDBwWoPHzgBmFrfXLPLPppN8n8bKxfOB7YDvAG+r29aKXDxqLHXlPgycVdxu6vvTKct0bZndGbgjIu6MiBXAOcD+dWX2JyUHgHOBvSWpjcdfAFxa3L6sZvsC4IqIGIyIp4FFwIRn04iIK0hJaDQr44iIW4D5kjYutvUBsyX1AXOA+ycaR7H/ByLiD8XtJ4GbSZXUtscTyVPF3f5iqb8acrT3qNbbgJ9HxNKJxlK0tL4ROHOUIg3jkLQA6IuISwAi4qnJxJFhrPfIbKUS+Wd/4DvF9/G3wLqSNmnj8d8FnBcRfyrKP1T8LZMfcmMZN/9FxG8i4rHi7m+BkbNB65Aq5t8syq2IiCWtjIX0fNcqfhfXJL2OgzT/N2rCr3XxOiwv7s5kkmebx8vFEXF3RCwChuse1/RcXOJ3odaBwA+L2019fzrFdK3MbgbcW3N/Mc/+oq4sExGDwOPABm08/nXAW4rbbyYljQ2K9ftKmiNpLrAnsHmT4mpkZRySdga2AOZFxH3AKcCfgAeAxyPi4mYdtDgFswPpv/Apiac4hXMt8BBwSUSMGgurv0e1DmBVEpmoLwPHUpcgS8SxNbBE0nnFqaiTJfVOMhZIPyQXS7pa0mFjxVP7HpV8rFmtMrmylbYG1lPqvnO1pPeObCiRHyZsjPxX6/2kVmuALYGHgW8V3/UzJa3R4lhOA7YlNRpcDxwVEcO04Deq5Gv91qILxrmSNq957OaSFpE+RydFxGQaXb7M2Ll4NK3IxaVikbQF6fMx0uDR7jpEJUzXymwnOAbYXdI1wO7AfcBQUUG7EPgNqZJ0JTDUwji+QGoNuZZ0quIaYEjSeqRWky2BTYE1JB3UjANKWhP4T+AjEfHEVMUTEUMRsT2pIrazavp+Fhq+RzXPYxPgxcBFE41B0puAhyLi6jGKjRZHH/CqYvvLSN1aDp5oLDVeGRE7kk5zHi7p1XXbG75HJR9rViV9wEtJLWCvAz4paWsolR8mZJz8N1JmT1Jl9h9q4twR+FpE7AA8DTzrWowmx/I64FpSvt0eOE3S2q34jSrxWv83MD8itiOdQj+75rH3FuufD7xvomeJSubi0TQ1F2fGcgBwbkQMAUxBHaISpmtl9j5W/09kXrGuYZnitPU6wKPtOn5E3B8RbykS0yeKdUuKvydGxPYRsQ+pP9FtTYrrWSLiiYg4pEgk7yX1jboTeA1wV0Q8HBEDwHmk/lyTIqmflDy/HxHnTXU8xTGXkE7f71u3ftT3qPAO4PwinonaDdhP0t2k7ih7SfpeyTgWA9cW3VkGgZ+QfvAmpWgFHznlej6p20zt9tHeo3Efa1anTK5upcXARRHxdEQ8AlwBvKS2wGj5YSLGy39Fme1Ip5b3j4iR36TFwOKaFstzmeR3vUQsh5C6YERE3EG6ZmEbaN1v1Bi5+NGa7gRnkv4BqX/s/cANpErlRIybi8fQ7FycE8uzzg62sw5RFdO1MnsVsJWkLSXNIL3ZF9SVuQB4X3H7bcClEdGsGSTGPb6kuZJGXv/jgLOK9b0jp7KLpLYd0LTT+/WUrpCdUdw9lNTX5gnS6fxdilMVAvYm9auazLFE6vN1c0ScOpXxSNpQ0rrF7dnAPsAtdWUavkc1avspTUhEHBcR8yJiPulzcmlErNbiPEYcV5FaSDcs7u9FuphlwiStIWmtkdvAa0k/ELVlGr5HZR5rVucC4L1KdiF1H3qgjcf/L+CVkvokzQFeDtxcJj/kKpn/nkP6R/09EbGyAhIRfwbulfSCYtXeTOK7XiYWUs7duyi/MfAC4M5m/0aVzMW1/aj3o8j9kuYVj6E4e/dK4NaJxFEmF4+hqbm4bCzS/2/vzuPlKsr8j3++d8kOJBBk2IMLYkYREAHFhUU06gwMiiMoKioyOCAgIuqoiMy4sIgbqBMRcQUdRIefoogCgwvIIhAgbCFsIUBYAiH7XZ7fH1WdnHT63luV28vp28/79Tqv231OdZ3qvt1PV9epRTsB0witr5V9Ta1DlIaVYBRaIzbCKNl7CLMKfDruOw04MN6eQBglPg+4Hnh+k89/CHBvTHMea0dkTiB8COYSBgDsMspyXEjoY9pH+PX4QeBo4Oh4/FWxDHcTgui0wmM/TwgqtwM/qpRxFGV5DaFP5RzC5atb4uvU9PIQPuA3x7LcDpyS+j+Kx2YQWpC66vie2Yc4ajWjHAfE53AbcAEwbpRleD6hz9WtwB2F9+6I/6OhHutb524J8UfAuYQ4eRuwezPPH9N8nBBvbydcbh8yPoyyLCnx7zxgceH4jYXH7wLcGB//q2JsbFBZtiJUgm6Lr8HhcX+9v6NSYvGXYky5ldByu1PcX4l/t8a/R9XpfbMPtWPxK+P7aBnhSu4dhcfUNRaPVJZ4/1Tgy1Xp6/r/aZfNl7N1zjnnnHNta6x2M3DOOeeccx3AK7POOeecc65teWXWOeecc861La/MOuecc865tuWVWeecc84517a8MuvcKEl6QNJJrS6Hc84514m8MltSkraQ9HVJ90laJekRSb+V9JZWl61MJM2QZJJ2T0j7aUl/kbRMks9J55xzzo0BXpktIUkzgL8T1sb+FGFS6TcAvwG+07qStb3xhEn+v9bicjjnSkjSBZJ+3eRzTpP0uKQXNPO8rjEk/Y+kj7W6HJ3GK7Pl9K34d3cz+7mZ3W1md5rZOYSKLRCWPpT0S0nPxe0SSdsUjp8q6XZJ74uXwpdJ+r6kcZL+XdLDkp6SdHZhudTKZfNTJf1Y0lJJj1VfRs8496Gxdfk5Sb+SNL0qn/dLmitppaR7JH20qiwm6agYIJZJmi+puKzf/fHvDTHt1UO9qGZ2ipl9hbDaTBJJV0v6TmwlXxy3M4tljCZI+m9JSyQtkPTxqnxOlDQnPodHJJ1XWcIxHt9E0o8kLYqvxXxJJ1Qdnx2PPyfp/1Jao51zpfcfwGVmdl9lh1+ZSxdj9DnDHH+dpEvja2iSjhgm7eaSvhW/A1fFHxl/lHRAIc0FMZ/qbZeY5DTg05I2qddzdCPzymzJSNoUmAWca2ZLq4+b2TMxXRdhXfEtgH3jthXwK0kqPGQGcBDwT8DbgHcQ1kN/JfBG4EjgI8DBVac6kbD+9W7A54AvSnrbBpz7nTHvNwK7Al8oPNcPAV8ETgFeAnwM+ATw71VlOSWe7+XAz4DzFdYwB9gj/p0FbBmfY729m/BZeRXwb8BRwAlVaT5KWMZwN+B04AxJryocH4yP+UfgXbHc3ywc/y/gZYT/04uBDxCWy62so/4bYOt4fFfgGuBKrbtmuXOujUiaRIjB3yvsm4FfmaunKYRlco8HVoyQ9heE2PxBYEdCvP0tsFlVuj8Qvm+K2+0AZnYbMB84HNc8rV5P17d1N8IHyYCDR0h3ADAAzCjsez6h0vSGeP9Uwod3k0Kai4EnKKwbDVwNnFO4/wBwRdX5zgP+nHnulVXn/jQwr3D/IeA9Vec5AZhbuG/Alwr3e4DlrF0nfEZMk7ymO3BIeOsnpb0auAfC0s9x32eABVWv14VVj7sX+Mww+c4CVgFd8f6lwPlDpN0PWApMrNp/C3Byq9+zvvk2VjbgAuDX8fZ4Qpekx2Msuw54TVX6ycAP4+fzcULl89fABYnnOwR4uiq+XEb4ITulRvqphdvDli/Grm8DX4nneIJQoRsPnAs8M0QMvppQaf46sDhuZ1ZiVcZrczXhKuMXgSeBRcBZhZgn4GTgPsL31G2VuJ6RxwWE+F/cZgzzei8Fjhji2NT4+DekvkeGSXMK8fvSt+Zs3jJbPho5CRBaMhea2QOVHWY2H1gIzCyke8jMni3cfxy4x8xWV+17XlX+19a4X8k39dwPVp17YeU8kjYHtgX+O3ZlWCppKfBloLrv2JzCefoJQbm6vI10ncUIFV0LbC1p48K+OVWPWfNcASTtJ+mK2AXhOULf3XHAP8Qk3wbeKelWSWdJen0hr1cAk4Anql6rl7L+a+Wcq48zCFeWPkC4GnIb8LuqqyFfAV5PuPq0H+Hq0WszzvFa4KZKfEm9MpdRvncDzwF7EmLr14BfEX6g7w78ADivxhWeka5GpZy7kk8/8Grg2JjHO+Ox/yK0gB5D+N74EuH74K0ZeRxPiMffZ20L6cNsmKVxO1DShA3Mo+J6YA9JE0eZj0vkldnyuZfw6/Alo8ijWPHqq3Gs1r56vRdGOnflPJW/RwO7FLaXEi7FFzWyvPUyZBklbU+4RHgnoZvHKwhfAhAqtJjZb4HtCa0O04HfSPp+TNNF+MGxS9W2E/DZ+j8V5zqbpMnAh4FPmNlvzOxOQqx6nFD5QtIUwuf4E2Z2hZndQaicDRby2Tb26Zwb+8y/o+pU2xN++Fa8kNCgcedoyxfdYWanmtm9wNmE1s0+M/u6mc0j9O8UsHfVKR4FjjOzu8zs54SW2RMzzw3hKtspZnZPzOcqYP+Yx4nAkWb2OzO738x+Cnw3NQ+A2FiyGlhuZo/FbWC4124osaHkCEL3gGckXRsbFvaskXxWsWFB0m+rji8Eegnd71wTlK1C0PHM7GngcuDYGCzXURg0dCewVexfVTn2fMKHZ24dirJXjfuVADvqc5vZ44QP/AvMbF71llHOSgtzd8Zjcu1Z1Rd4L0LL9JLEx+9OqLR+1MyuNbN7qBHkzOxJM/uRmR1B+FJ8n6TxhP5zWwCDNV6rRaN5Ys65ml5AqIz8pbIjVpKKV6gqaa4vpFlG7DsZ9QMnmNlMwriBr8WKXMVEwmX6itQrcynlg3WvahnhMv1thX19hG4E1Ve6hrsalXrudc4fVa5YzQQmEFpzi1ebPswwV+aq8qg7M/sFITb/M6Gv7KuB6yT9R1XSa1i3YeHIquOVvrneMtskPa0ugKvpGEKguFHSZwkfZhEGWn0K2I7QAX0O8BNJx8fHfZNQ8bmyDmXYS9KnCH1s9wHeS7jcQx3P/Tngm5KeIfQT6yUMoNrazL6UmMciQuB4k6QHgJVVXRvWiIPGNiX0s6Uw+nRerUt6BVsRvoS+RRik9XHCJbJU9xJ+OJ4g6RJCZfiEqrKdRnj97iB8Lt8GzDezVZL+QHg//K+kk4G7CN0TZgF/MLM/ZZTFOTc6yXNUm9mjhFZOzOwxSU8SYtCymORJYFrhIcUrc7+sQ/laeWVuqPN3Fc73z4R+u8M9pqlX5sxsJXBF3E6TdB5wqqSzCt3zlo/Q6LJp/PtEo8rp1uUtsyUU+5/uRvgwnU6oOF4JHEjou1T5lX0Q4cNyVdweA/6l6hf1hjqbMIr2ZkLF7RQzu7ie5zaz8wiX6d4D3Ar8KT6/+4d7XFUe/cBxhF/GCwmzHgzltPh8zoz3b47bSFNc/YTQ8vs3wmWw7wFfzSjjHELfrhMJLddHAtUrhq0izPRwK6HiuhEh0Fde77cQ3gPfBe4Gfk6Y9WAhzrl6u49w1WfN5XdJ3YQ+pHMLafoIM8NU0kwidJVaj6RXAN1mVuzTeTOF1syMK3Mp5RuN4a5G1ePccwkxb/saV5sezCzrahp7ZW4uoYEhpx/tS4FH4hVI1wz1HlHmW/tvhNH5J7W6HGXYqJrpwTfffBu7G+vOZvA1QqvqWwgtpbMJA4S2LKT/ToyX+xMqpT8FngW+X5XvpoSrLq+u2v8ywswwmxX2PT+e9y5CH/sXE/rHf5gwoJeU8tWKXYQuEKdW7XsMOLZw/2rCoLGvx3MfQpj54KTUcw9z/uLr+1/AU4QGjRcSLtcfDRyVmke8Pxu4iXDFbTqFWRfi8Sms7Q6wnDDTwC7AdlXpNiM0GBxOaMjZIb7+j1GY3af6/MO8j77X6vdzJ23ezcA555xb3yfi3+8Tpm26GZhloetAxUmE6bkuJVTmvkro376mH2zs9/4r4Mtm9tfiCczsNknXA4cSpsvCzOZL2o2wmMLphPmlnyJctTkqs3wbqng1ylj/alQ9zv1ZwqCxkwizuSwhTDd4RmZZzyLMyjCX0Ed1B8IPjIrdCVcPKz4ftx8QBnxVLCVMMXY8oXI9njBF2k/J6FYWZ0I4mDBPsGsSxV8Rzq0R+56eY2ZntbosraawotjtZnZsq8vinCu3WHF9EDjTzL4SL9X/FLjbzE4d4jGzCK2gM20DR+LXk8e80ZF0DHCQmb2x1WXpJN4y69ZjZjNaXYayMLN9Wl0G51w5SdqVcJn9ekI/90/Evz+LSfYmzIk6R9K/xH3vsbBKFABm9jtJ5wLbECrCrr31EVbVdE3klVnnnHNuw51I6FvaT7hM/jozWwBgZn8mYaC1mX2jkQV0zWNms1tdhk7k3Qycc84551zb8qm5nHPOOedc2/LKrHPOOeeca1temXXOOeecc23LK7POOeecc65teWXWOeecc861La/MOuecc865tuWVWeecc84517a8Muucc84559qWV2adc84551zb8sqsc84555xrW16Zdc4555xzbcsrs84555xzrm15ZdY51xEknS9pkaTbhzguSd+QNE/SHEm7NbuMzjk3ljUqDntl1jnXKS4AZg1z/M3Ai+J2FPDtJpTJOec6yQU0IA57ZdY51xHM7Brg6WGSHAT80ILrgKmStmxO6ZxzbuxrVBzuqVcBy2j81Ak2ecuNktP3DXYnp+0fyPsdMNiXl75rtZLT9qywvLyX92Wlt/6M9HlFyaP01wRA3XmvuY0fl5x29cZ5eU+btjQr/ZSulclp+y39fQvQ18D0uXkvvuvJJ81s81rH3rTvZHvq6YGkfG6as+oOoPiizTaz2VmFga2Bhwv3F8R9j2bm4wrG9U62CeOnJqfXytXJaW0g7f2xoZQTc3p7s/K2cXmflf4J6TFncHxW1lhPRuDOC8P5cr5Dsr9vMgvfyO+zXA0sy+oFC4aMw9D0WLxBcXhMV2Ynb7kRbzz/4OT0j69Ir/guem5KVlmWPp6XftKD6f+azW/Nq5xOvvWRrPQDjy9KTmv9/Vl551BvemUToGuT9P8nwMALt05O+9Ab8/6fBx/856z0e290T3Lap/rzyvJo37S89Ks3SU67aGXea/6zV3/3waGOPfn0AH+7fJukfHq3vG+lme2edXLXFBPGT2XPnY9OTt9998MjJ4oGFi/OK0zmD+Ku8em1wq4tt8jKe/V2m2alX7zjhOS0S3bIypq+zdLjtsYPZuVtg5kVyIGM9DlpAWWmJ+e3kmWWJe9lbGhl9oGPnjRkHIb2iMWl6GYgaZaku2OH30/WOD5e0s/i8b9JmtGCYjrnmsoYsMGkrU4eAbYt3N8m7usYPkjOObe+psbiDYrDLa/MSuoGziV0+p0JHCZpZlWyDwKLzeyFwFeB05tbSudcsxkwiCVtdXIp8N5YYdsLeNbMOq2LwQX4IDnnXEGTY/EGxeEydDPYA5hnZvMBJF1E6AA8t5DmIODUePti4BxJMrMy9WhxztXZIHVrdUXShcA+wHRJC4DPAb0AZvYd4DLgLcA8YDnw/rqdvE2Y2TUjXPlaMzgDuE7SVElbdmCl37mOUq9Y3Kg4XIbKbK3OvnsOlcbM+iU9C2wGPNmUEjrnms4wBur4e9XMDhvhuAHH1O2EY5MPknOuw9QzFjcqDpehMltXko4iXP5i0hZ5A2Occ+VSxy4EromKcXjCuPQBhM65cip7LG55n1nSOvuuSSOpB9gEeKpWZmY228x2N7Pdx09LH/3pnCsXAwawpM01TdLgjGIc7u2d3LTCOefqrx1icRkqszcAL5K0g6RxwKGEDsBFlwLvi7cPAa70/rLOjW0G9Nlg0uaaxgfJOddh2iEWt7ybQewDeyxwOdANnG9md0g6DbjRzC4Fvgf8SNI8wsoRh7auxM65ZvFqanP5IDnnXC1lj8Utr8wCmNllhCBZ3HdK4fZK4B3NLpdzrnXMuxA0nQ+Sc85Va4dYXIrKrHPOrcdgoNzx0znnxr42iMVjujLbN9DNwmXpI2mfXj4xOe2yJXmDy3qW5K3DPW5Jetqu1ZkXADKXdKQ7o+wNXis9y+q8ZX67n1qanHbjB/IGtVx6/8uy0i/fPn3p3u7MC0DP9E3KSr94dfrn4umV9RvsEybqdm2vSwxMSP+q6R7Xm5715Lz3mybmxW1lLGc7uEleWQbG530nDGZ8W1te1llL1PaMz1uyfDBzmdec5W+tP2/YT/bSujkBKPd5lrxyWNQOsXhMV2adc+1MDJD55eOcc67Oyh+LvTLrnCslAwbbqPXCOefGonaIxV6Zdc6VVtlbA5xzrhOUPRZ7ZdY5V0phou5yB1DnnBvr2iEWe2XWOVdauYNHnHPO1V/ZY7FXZp1zpdQOrQHOOTfWtUMs9sqsc66UDNGXO8eQc865umqHWOyVWedcKbVDa4Bzzo117RCLvTLrnCspMWB5k6I755yrt/LHYq/MOudKKaw6U+4A6pxzY107xOIxXZntH+ziqWXpS3euWJG+hKgty3vpep/La6LvWZ4+Q3H3qsyF5jLX0VPOcrY96UtR5lJ3Yz9MWrEqOe2kx/OWyn163sZZ6f86fofktNMmrMjKe/VgXt+nFX3p/9Nlq9I/QynKfmnLjWywR6ycnv4eGrdp+hLkXRPSl5sFGNwob8nZwYwlZ1dPy1sqd9XUvO+Qvinpn4WBiXnLinePS08/fkJe7Ms1mLHk7MBA3ndCTt5A9hK1paH6r3BQ9lg8piuzzrn2ZVb+S1vOOTfWtUMs9sqsc660BkveGuCcc52g7LG43FVt51zHCiNou5I255xzjVHvWCxplqS7Jc2T9Mkax7eX9EdJcyRdLWmbkfL0bwHnXEmFS1spm3POuUapXyyW1A2cC7wZmAkcJmlmVbKzgB+a2c7AacCXRsrXvwWcc6VUGUGbsqVoRGuAc86NdXWOxXsA88xsvpmtBi4CDqpKMxO4Mt6+qsbx9Xhl1jlXSoZYbd1J20ga1RrgnHNjXWYsni7pxsJ2VFV2WwMPF+4viPuKbgXeFm8fDGwkabPhyugDwJxzpTVYvy4Ea1oDACRVWgPmFtLMBE6Mt68CflWvkzvnXDvLiMVPmtnuozzdScA5ko4ArgEeAYadP84rs865UqoMOkg0XdKNhfuzzWx24X6t1oA9q/KotAZ8nUJrgJk9lVVw55wbQzJj8UgeAbYt3N8m7lt7PrOFxJZZSVOAt5vZM8Nl6pVZ51wpGWIgfdLylrQGOOfcWJcZi0dyA/AiSTsQYuyhwLuKCSRNB542s0HgU8D5I2XqlVnnXGnVcQnFhrQGOOdcJ6hXLDazfknHApcD3cD5ZnaHpNOAG83sUmAf4EuSjNCwcMxI+Xpl1jlXSmbUc9qthrQGOOfcWFfnWIyZXQZcVrXvlMLti4GLc/Ic05XZwUGxfGn62t2Dy9Nfjp4leevb9y7JSs64ZelrK3f1ZV4J7ckruyamrzmunv68suTozis349LXgwegN/3/37s073lOeWBcVvonpkxLTrt4at568909ee+XrLXS+zL/R8NS3VadaVRrgBvZYDes3CT9i3DyJhOT03YP5q1BbxPyvvKsJ73cOWkhvC5Z6TOKbr15r8u48X3JaadMWJWVd7cy/0cZaQcG817z3PRloozXsSvzNb9v5LOXfgWwMV2Zdc61L6P8rQHOOTfW1TsWN0JTSzeaScslnS7p9ri9s5nlds61hi9nW3+Szpe0SNLtw6TZR9Itku6Q9H9x3wRJ10u6Ne7/fPNK7ZxrpbLH4qadeTSTlkt6K7AbsAthOp2TJG3cpKI751rAEIOWtrksFwCzhjooaSrwLeBAM/tH4B3x0CpgPzN7OSEWz5K0V0NL6pxruXaIxc3sZjCaSctnAteYWT/QL2kOIRj/vAnlds61gAF95j2h6s3MrpE0Y5gk7wIuMbOHYvpF8a8BS2Oa3rjldc5zzrWddojFzWwTHs0SZrcSWgEmxRHH+7LuNDvOuTFHDCRurq52BKbFrl43SXpv5YCkbkm3AIuAK8zsb60qpHOuWcofi8tW1a45abmZ/V7SK4G/Ak8A1zLEZOZxHeCjALo326QZZXbONYBR1+VsXboe4BXA/sBE4FpJ15nZPWY2AOwSuyL8UtJLzWy9vrfFONybMTOHc6582iEWN7N0SZOWm9nbzGxX4NNx3zPx7xfMbBczOwAQcE+tk5jZbDPb3cx27944b8oi51y5lL01YIxaAFxuZsvM7ElCw8LLiwliXL6KIfreFuNwzwSPw861u7LH4mZWZtdMWi5pHGHS8kuLCSRNl1Qp05pJy+Olrc3i7Z2BnYHfN63kzrmmMxOD1pW0dQJJ42P8nClp8wae6n+B10jqkTSJMOj2TkmbxxZZJE0EDgDuamA5nHMl0A6xuGndDEY5aXkv8CdJAEuAw+NgMOfcGFb2uQ0bTdJGwOHAYYRBtL2EK1Mm6RFCPJ1tZjdk5HkhIdZOl7QA+FzMFzP7jpndKel3wBxgEDjPzG6PDQk/iDPTdAE/N7Nf1+mpOudKrOyxuKl9Zjd00nIzW0mY0cA51yEMSr/qTCNJOpHQ3Wo+4SrWF4CFwApgU+ClwGuBKyRdB3zEzO4dKV8zOywhzZnAmVX75gC7Zj4N51yba4dYXLYBYM45F6n0rQENthfw+loDrKLrgfMlHQ18EHg9MGJl1jnn8pQ/Fo/tymx/F/bMuOTk3avSf3n0Lsv7ldK7PG86xq6+9PTWlVcWG5/+mgCov+bEEbXz7sns/ZGxtrq6Mz9Mvb1Zya03/ePQtTr9NQGY8mhe+v4p6WVZ8by812X1xMy10rsy/kf99fv1HkbQlrs1oJHM7F8T060iLHJQStYFfVPS/499G6fHp67lq/MKo8xYmZF+sDcv7/4JeekHJqSn1aS8OLzxpJXJabecvCQr7wndndEjsEuZ3/EazErfm5E+tywj9VFqh1ic/C0oaQtJJ0n6dpzrFUl7S9qhccVzznWysi+h2GiSdi4MinXOuZYoeyxOOrOkVwB3A+8mXM6qLCV7AKEfl3PO1ZUh+q07aRvDbgamV+5I+o2kLVtYHudch2mHWJxajT4L+Hqc/3VVYf/lwN51L5VzruOZwYApaRvDqp/c6wgLGTjnXFO0QyxO7Zj3CkKLbLVHgS3qVxznnFur7P20nHOuE5Q9FqdWZlcAtdYk3ImwRrdzztWVoY5ZEGEYFrfqfc451xTtEItTK7P/C3xO0jvifZM0Azgd+EUjCuacc75ULQJ+LKnSvWsC8F1Jy4uJzOzAppfMOdcxyh6LUyuzJxEWO3gCmAT8mdC94C/AZxpTNOdcJ2uH6WCa4AdV93/cklI45zpWO8TipMqsmS0hrNW9H7AbYeDY383sD40snHOuk5X/0lajmdn7W10G51ynq28sljQL+DrQTVgu+8tVx7cj/JCfGtN8Mq4gO6SsRRPM7ErgyniyvBnpnXMuU9mXUGwVST3ABDNb2uqyOOfGvnrFYkndwLmEqV0XADdIutTM5haSfQb4uZl9W9JMQs+AGcPlmzrP7HGS3l64/z1ghaS7Jb0476k459zI2mE6mEaTtL+kf63a90lgKfCMpN9JmtqSwjnnOkKdY/EewDwzm29mq4GLgIOqT8na9Qw2ARaOlGlqy+xxwAcAJL0O+FfgXcDbga8A/5SYT1NpAMYtTm8a7+pL/1LsWZZXlp7M5WyVscxr7nK25C4L25M+EXJDqxVdjSs3kLXUpfrylqed8GTespubdKcv6dmzPO95rtokKzmD41s3eL7TuxkAnwR+W7kjaQ/gi8D3gDuBjwOfjn9Lybph9dT09Cs2S79g2L0ib8pd686LUIM96en7J+a9V/snZS5nm/E57Bmft4TsJuPTl7PdfELexYCNe9LzBhjflV727swlYbsyJwLpVXqc780od27eABPU17C8z09IkxGLp0u6sXB/tpnNLtzfGni4cH8BsGdVHqcCv5f0EWAy8IaRTpoaNbYG7o+3/xn4HzP7uaTbgD8l5uGcc8nCqjPl7qfVBC8jVGgr3gH81cw+BCDpYeC/KHFl1jnX3jJj8ZNmtvsoT3kYcIGZfUXSq4AfSXqpmQ356yW1dEuA58XbBwB/jLf7CFPFOOdcXVVG0KZsIyn003ozMBM4LPbFKqr009oVOBT4Vn2f0QaZyrpzee8N/K5w/wZCY4NzzjVEPWMx8AiwbeH+NnFf0QeBnwOY2bWEeuZ0hpFamf09YW7D84AXsvay1z+ytsXWOefqatC6krYEDemn1QSPAi8AkDQe2BW4tnB8I9ZdYtw55+qujrH4BuBFknaQNI7QcHBpVZqHgP0BJL2EUJl9YrhMU7sZHAN8AdgOOMTMno77dwMuTMzDOefSpf/Shxb102qC3wJnxEFfBwLLWLdr187AvFYUzDnXIfJi8fBZmfVLOha4nNCd63wzu0PSacCNZnYp8DFCA+pHCY0MR5jZsB2ec+aZ/UiN/Z/LfB7OOZfEyJoOpiX9tJrgFOAS4A+EGQzeF1uWKz4AXNGKgjnnOkNmLB45vzAW4bKqfacUbs8ldKlKljXPLICkfwDWGWptZg/l5uOccyOp46ozqf20ZkHopyWp0k9rES1iZk8Cr5O0CbDUzKqHKb+DUMl1zrmGGRMrgMVA+g3ClFy15gzKnAPJOeeGV+clFNf00yJUYg8lTC9YVOmndUFqP61mMbNnh9j/dK39zjlXL+2wnG3qALCzgJcD/wKsJHwJfJzQ7+ydDSmZc67j1WsErZn1A5V+WncSZi24Q9Jpkg6MyT4GfEjSrYSxACP203LOuU5Qx9kMGiK1m8GbgcPM7E+SBoCbzOxnkh4F/g24uGEldM51JKO+wbER/bScc26sq3csboTUltmpwIPx9rPAZvH2tcCr61wm55wDwqCDlG0skzRV0lslvVpad5k6SZMlnTLUY51zrh7KHotTK7P3Ac+Pt+8EDo1B9W2A99lyztWdGfQPdiVtY5WkfyTE3P8F/gzcIGn7QpIpgM8q45xrmHaIxandDC4gzGd4NfBl4NeE/mddwPGNKFg9dPXDhCfTfynkLPPcszxzjecVeem7V6Wn12Bmt76uvDec9aZPeqHMvMnpkqi8X33WnVmWroz8M7tSdq9IX1cbYNLC9DdjV9/4rLx7l+aN1+ybnP66WJ2Hgpb90lYTfIlwBew9hAUdvg78RdK+ZnZvS0uWyHpg9bT09/PKzdI/tz0ra41HHpoyP7eD3envv1Ub5b1X+ydnJWdgYnrZJ4/vz8p7Sm/6uhtTe1dk5T2997ms9BOUXvbxXXlxdVxG3qEs6flPyCzLJOWtdZKT/ziqJz0ZvbLH4tR5Zr9auH2lpJ2A3YF7zey2RhXOOde52qGfVhPsBexrZssICyb8q6Szgasl7Uvo9uWccw3TDrF4g9qEzewhM7skpyIr6XxJiyTdPsTxaZJ+KWmOpOslvbRw7KOS7pB0u6QL4/yPzrkxzkxJ2xg2njAzzhpmdiJh3fKrgZfkZihpW0lXSZob4+p6V9ckvTvG4tsk/VXSywvHpkq6WNJdku6MC0w458awssfi5OvHkvYkzMH4PKoqwWZ2XEIWFwDnAD8c4vh/ALeY2cGx5fdcYH9JWwPHATPNbIWknxPmiLwgtezOufY01gd3JbibcBVsbnGnmX1UUhehL22ufuBjZvZ3SRsBN0m6Is7mUHE/8HozWyzpzcBs1i7/+3Xgd2Z2SFxbfdIGlME510bKHotTF004CTiDsAb4QtZtKUjqyGNm10iaMUySmYT+uJjZXZJmSNqiUM6JkvoIgXNhyjmdc+3LrPz9tJrgl4RldtdrBDCz4yX1AB/OydDMHgUejbefk3QnsDWFCrOZ/bXwkOsIK6ZVFtB5HXBETLcaKC6v65wbY9ohFqd2MzgeOM7MdjSzfcxs38K2X53KcithdgQk7QFsD2xjZo8QFm14iBCAnzWz39fpnM65Eiv7pa1GM7Mvmdmbhzl+jJlt8BDi2MCwK/C3YZJ9EPhtvL0DYVW070u6WdJ5kjKHMjnn2k3ZY3FqENyYqsnGG+DLwFRJtwAfAW4GBiRNAw4iBNGtgMmSDh8qE0lHSbpR0o39K5Y1uMjOucZJW3Gm7C0GZSVpCvAL4AQzWzJEmn0JldlPxF09wG7At81sV8KgtE/WeNyaODyw1OOwc+2t/LE4tTJ7ITCrkQUxsyVm9n4z2wV4L7A5MB94A3C/mT1hZn3AJQyzUIOZzTaz3c1s956J3mDgXDsre2tAu5LUS6jI/sTMLhkizc7AecBBZvZU3L0AWGBmlZbciwmV23UU43D3FI/DzrW7ssfiIfvMSjqxcPdh4POS9gbmAOtMeGZmZ4+2IJKmAstjH6wjgWvMbImkh4C9JE0CVhAGod042vM558rNKH8/rWaRtB3wsNm6E6XGxWu2NbOHMvIS8D3gzqFidzzfJcB7zOyeyn4ze0zSw5JebGZ3E+Lx3Fp5OOfGhnaIxcMNAPtI1f2lhBbR6lZRA0aszEq6ENgHmC5pAWHVml4AM/sOYYqZH0gy4A7CpS3M7G+SLgb+ThiFezNhZK1zbiwzGCh5AG2i+4EtgUVV+zeNx3KWq9ibsAjDbbFbF4TZZLaDNfH4FMKy5d+KK+j2m9nuMe1HgJ/EmQzmA+/PfTLOuTbSBrF4yMqsme1QzxOZ2WEjHL8W2HGIY5/Dl2x0rqMYeBeCtUTtmWOmACtzMjKzP8f8hktzJOEKWa1jtxCmC3POdYB2iMXp65RGcdAAZra0/sVxzrkKH9wl6RvxpgFfkrS8cLgb2AO4pdnlcs51kvLH4pxFE04ATiTMR4ikhYTuBV+r7sdVFuqHCU9lrHGfsZxx96q8p9y7LG+tZA2k529deW8y6825Ignqz0g/2MC3QubbTAPp/3sAU/r/SF0bPBtSkq6M5zru2bz/Z66elenPdbDORSlnZGmql8W/InTFKs7puprQ/eqsZhcqS7cxuEn6uvIrNxufnLZrdd7nUHkhYYT263Wt3jgvDq/eOO/NbZP7k9NuPDGrsZ7NxqfPOLFpT97sFJt256XfqHtFctoJSn9fAUzuWpWXXulTKE/qyiyL0v+fAOMz3l4TVP+KZ9ljceqiCWcARwFnAtfG3a8i9KvaEji5IaVzznW0sl/aajQz2xdA0veB44eaQss55xqp7LE4tWX2SOBIM7u4sO9KSXcD/41XZp1zdWZW/gDaLGbmg6yccy1R71gsaRZhWexu4Dwz+3LV8a8C+8a7k4DnmdnU4fLM6TM7Z4h9jb3e6pzrWGXvp9VMkt5JmArreVTFXTM7sCWFcs51hHrFYkndwLnAAYR5q2+QdKmZFZfT/mgh/UcIqxQOK7Ui+kPgmBr7Pwz8KDEP55zLEloERt7GOklnAj8GZgDPAE9Vbc451zB1jMV7APPMbH5cV+AiwiqvQzmMsHDXsFJbZscD75L0JuC6uG9PwvKyPymMuMXMjkvM0znnhuXdDNZ4L3BYVVcv55xrioxYPF1ScWGr2WZWXBtga8JCXBULCPXJ9UjaHtgBuHKkk6ZWZncijJoF2D7+fSxuLymk64A2EudcMxi+VG1BFz4Fl3OuBTJj8ZOFBVZG61DgYjMbcaqhpMpsZUStc841jXmf2YLZwOHAqS0uh3Ou09Q3Fj8CbFu4v03cV8uh1O7iup7sRROcc65p6nitpxEjaJtoKqGr1wGEgbfrTGrp3buccw1Vv1h8A/AiSTsQKrGHAu+qTiRpJ2Aaa6eDHZZXZp1zpVWvbgaNGkHbRDNZ281gp6pj3r3LOddQ9YrFZtYv6VjgckLDwvlmdoek04AbzezSmPRQ4KLURbm8MuucK606zlSwZgQtgKTKCNq5Q6Q/DPhc3c4+St7VyznXSvWcNcbMLgMuq9p3StX9U3PyHNOVWRn0ZCw7m7NEbfeKvOVpe5bnLV2Xs0Stct9kg5lrOuakH8h7XchZcjb305S5pJ8y8reevHVbrSfvozY4Lj29dTe2X2lXf/rr0pX3Nh+WUf4RtG5k6jLGTUpf6rNv4970tEszpzlvYBt23+S89P2T8grTPSn9w7XRuLxlWzfuSV/+dkp33lK5OcvTAmzclZ7/pAYuTwswKWPJ2Y268r5Xc5ecnaT0z8V41bdqlxmLW2JMV2adc23MgJKPoG0mSW8GjgWeD7zRzB6WdCRwv5n9sbWlc86NWXmxuCVGtXqXpC5J29WrMM45V1THibpzR9COOEl3M0l6N/Bz4B7CwgmVZppufDlx51yDlX0Bm2Ers5ImSPqOpCck3SPp+KokmwP3N654zrmOZonbyNaMoJU0jlBhvbQ6Ue4I2iY6GfhQHKRWvPZ5HbBLS0rknOsc9YvFDTFSN4NTgH+KfzcBPiPplcB7zazSQaTcbc/OuTZVv0UTGjWCtoleRO0K9lJg4yaXxTnXUcq/gM1Ildl3EloDfgsg6ULgt8BPJVXmBStb0HfOjRUlH0HbRAuBHYEHq/a/Driv+cVxznWUktf0RuozuyVwZ+WOmT1ImFT8ZcBFrO235Zxz9WVhBG3K1gFmA9+QtHe8v62k9wFnAN9uXbGcc2NeG8TikVpmHwVeCDxQ2WFmj0vaH7gK+GHjiuac63idUVEdkZmdIWkT4ApgAiH+rgLOMrNzW1o459zYV/JYPFLL7FXUWGbMzB4D9iOMCHbOucYo+aCDZjKzTwPTCQtA7AVsbmafbW2pnHMdoeSxeKSW2f9k/aUTATCzRyW9Hnhj3UvlnHPQMRXVFJLeCewPPI/YEKE48bqZHdi6kjnnxrySx+JhK7Oxj2z1gIPi8UeBH9S7UM451w4TdTeLpDOBEwhXyxZS+q8W59yY0Qax2FcAc86VVukmyGqd9wKHmdnFrS6Ic67zlD0Wj+nKrAn6x6f/mlDG0sq9SzPX1V6evjY5gFalp7fe7ry8V+StT63VGWXPSQuN/YRkrn1Nb/rHYXDCuKysV02fmJW+f1L6/3Qw81M82Jv3ugx253yG6vz/LHkAbaIu4JZWF2JDSMa4celr3C8bn/5PH8j7GDbU4Li8N6tlph/Xm7668qSevBg/viv9/9OrvFWex2Wm7yL9i7g7I21In/m9rfT0ed/C0Ku8BVi7M77PujPzTlLyWNyAZ+ycc3ViStvGvtnA4a0uhHOuQ5U8FjetZVbStoSpvLYg1PFnm9nXq9JMA84HXgCsBD5gZrfHYx8FjoyPvQ14v5mtbFb5nXPNl9EwMtZNBd4l6QBgDrDOJRAzOy41o8RYvAnwY2A7wvfEWWb2/XjsdOCtMel/mtnPNuQJOefaR9ljcVLLrKQrJU2tsX9jSVcmnqsf+JiZzSRMK3OMpJlVaf4DuMXMdib0Eft6PM/WwHHA7mb2UkKL/qGJ53XOtaPUqWBKHmTrZCahm8FqwgwzLytsL83MKyUWHwPMNbOXA/sAX5E0TtJbgd2AXYA9gZMk+XK6zo1lbRCLU1tm9wFq9U6aALw2JYM488Gj8fZzku4EtgbmFpLNBL4c09wlaYakLQplnSipD5hEGNHrnBuzOqYLwYjMbN865pUSiw3YSGHurynA04RK8EzgGjPrB/olzQFmAT+vV/mcc2VT/lg8bGVW0m6FuztLerpwvxt4E/BI7kklzQB2Bf5WdehW4G3AnyTtAWwPbGNmN0k6C3gIWAH83sx+P0TeRwFHAYybPC23aM65Mskb3+EyDROLzwEuJTQabAS808wGJd0KfE7SVwiNCvuybiW4ku+aONy7+SYNK79zrklKHotHapm9kbWNx7UqjyuAj+ScUNIU4BfACWa2pOrwl4GvS7qF0C/2ZmAg9qU9CNgBeAb4H0mHm9mPq/M3s9mEwRJM3mzbzrgA6dxY5Z/gNeJVqmMIraNGqER+y8we38D8hovFbyJ0a9iPMIbhCkl/MrPfS3ol8FfgCeBaYL3h6sU4PPGFW/l/0bl2V/JP8Uh9ZncgBDIRllDcobBtDWxsZuennkxSLyF4/sTMLqk+bmZLzOz9ZrYLoc/s5sB84A3A/Wb2hJn1AZcAr049r3OuDVUm6i7xCNpmkbQ3MI+wvPgKwgDZdwP3SnrVBuQ3bCwG3g9cYsE84H7iapBm9gUz28XMDiB8N9yzIc/JOdcm2iAWp6wABnWYwiv2vfoecKeZnT1EmqnAcjNbTZi54BozWyLpIWAvSZMIgXx/Qquxc24MK/sI2iY6C7gQONrMBgEkdQHfAb5Cxo/7lFhM6NK1P6HL1xbAi4H5krqBqWb2lKSdgZ2pfdXOOTeG1DMWS5pFGODfDZxnZl+ukeZfgVMJVelbzexdw+WZPDWXpG2A11FYF7ximIBYtDfwHuC22I0AwuwF28U8vgO8BPiBJAPuAD4Yj/1N0sXA3wmDEG4mXsJyzo1hXpmt2AU4olKRBYh9WM8mxMMcKbH4P4ELJN1GaH39hJk9KWkCoYILsAQ4PA4Gc86NZXWKxfEH8bnAAcAC4AZJl5rZ3EKaFwGfAvY2s8WSnjdSvkmVWUnvJsz/2k/oJ1V8WgaMWJk1sz8TguJwaa4Fdhzi2OeAz6WU1znnxphnCd277q7aXxlHkCwxFi8E3lhj/0pCn13nnNsQewDzzGw+gKSLCGOiigNJPwSca2aLAcxs0UiZprbMnka4lPVZM8tbm66FBntgxfT0HhL9y3N+evRmlaXnubzlBbueWpGcVj2ZC+n1Z/4L+9MbXmwwc8hjzvKnXXn9cdSb9z+ySROS0678h0lZeS/dKm99kv7J6c/VMjsB5abPoYH69pnybgZrXAR8T9LJhMFXEFpYTyd0P3ApGtmlr0RdtwczP+SDGX0dc9ICrLa876depafvs7y4ujpzad3ejNdx5frjIIfVbXnfld0Z+Xc1YHHXOsbirYGHC/cXEOasLtoRQNJfCF0RTjWz3w2Xaeo7YQtCv4a2qcg658aADhjclehkQnXpfNbG7T7g28AnW1Uo51yHSI/F0yUVxzTNjrOb5OgBXkRY42Ab4BpJLzOzZ4Z7QIrLCDXn+ZkFcs65DdM5q3uNKA6KPV7SpwgzzADcZ2bLW1gs51wnyIvFT5rZ7sMcfwTYtnB/G9Zfr2AB8Lc4e9X9ku4hVG5vGCrT1MrsFcDpkv6RMP9r9brgtaZ2cc650fHK7DrMbLmk+yu3W10e51yHqF8svgF4kaQdCJXYQwlTDhb9CjgM+L6k6YRuB8M2pqZWZv87/v2PGseM0KfBOefqSiVfdaaZJJ0AnEjoc4akhYTBt18zM6/2O+capl6x2Mz6JR0LXE6oO55vZndIOg240cwujcfeKGkuYVGWj5vZU8Plm1SZNWvkkBHnnBtCyec2bBZJZxCWhz2TsOoWwKuAU4AtCX1qnXOuMeoYi83sMkL31eK+Uwq3jfDD/cTUPPOGAjrnXJPI6jeCtlFzGzbRkcCRZnZxYd+Vku4mXDnzyqxzriHqGYsbJanFVcG/S7pD0nJJz4/7PxlbMpxzrv7qt4TimrkN42CqytyGRdlzGzbZnCH2+ZUz51xjlXw529QgeDzwGcKqW8XSPgIcW+9COeccsHYU7UhbnA6msB1VlVOtuQ23rkqzI7CjpL9Iui52SyiLHwLH1Nj/YeBHTS6Lc67TpMfilkjtZnA08CEz+42k/yrs/zvwj/UvlnPOZV3aGmk6mBTZcxs20XjgXZLeBFwX9+0JbAX8RNI3KgnN7LgWlM85N4aVvZtBamV2e+D2Gvv7gIn1K45zzhXUL4A2ZG7DJtqJ0HgAIR4DPBa3lxTSlfwrxznXlkoeWVIrs/OB3YAHq/a/hXXX03XOufqo76CDhsxt2Cxmtm+ry+Cc61BtMAAstTJ7FnCOpEmEPrOvkvQewgjaDzSqcKM12AvLt0r/D3SvSs979cZ5U+sO9kzJSr/Jir6RE0VasiwrbwbzJoyznPSDjXvHqytvnIuN781K3z81/SLD8i3yJgJZtk1ex/i+KRmvY4mijAbqPACgTk+tUXMbupGZib6+9Hip/vT3UFfmAuvZ41My0ueUe0PSD/Snx7+VA3nxadVgevrlg+Oz8u4dyPsnDWbMBDqQ+Z2w2jK/t7tWZpQl/TsbYHCwPyv9gNLT9zVigu7yfM3UlDrP7Pcl9QBfBCYRBhwsBI4zs581sHzOuU5W8rkNm0nSFsDewPOoGrxrZt9qSaGcc51hLFRmAczsu8B34+W3rhJOW+OcG2NK1OjcUpIOB84jtBUuZt2vFgO8Muuca5iyx+LsRRPM7MlGFMQ559ZT8gDaRF8AzgBOM7O865POOTdaJY/FSZVZSZsSgun+1L7EtXH9i+ac62htMOigiTYGLvCKrHOu6dogFqe2zH4P2JWwaMJCSl9Hd86NCR5pKn4CvBX4ZqsL4pzrQCWPxamV2f2BA8zsb40sjHPOraPkAbSJTgR+JWl/4DbCHN9rmNlpLSmVc64zlDwWp1ZmFwFLG1kQ55wrEuW/tNVE/wbMAp4EXsj6A8C8Muuca4h2iMWpldlPA6dJep+ZeaXWOdccJQ+gTfRZ4GNm9tVWF8Q514FKHotTK7OfAWYAiyQ9yPqXuHauc7mcc52uDQYdNFE3cGmrC+Gc60BtEItTK7MXN7QUzjlXS8kDaBN9H3g33p3AOdcKJY/FqSuAfb7RBXHOufWUPIA20STgSElvAuaw/tWx41pSKudcZyh5LM5aNEHSfsBMwtO6w8yubkSh6mbcIINbpa+t3L86fd3m1VPz1njun5iXvqtvanLaje7Im3pSy1Zkpc/Slbk+uTLSj+vNytsm5a0hvmrTcclpl22Z9zxXbrs6K33vlPT0XV15UcYyF6gfHEhf/3xwIC/vkTRiifE29RLg5nh7p6pjpf6aMROrV6Z/drtXpr+HulZlFqa+b891ZH6sGBif94Cc76flfemxDOCZvknJaTfuSf9O3RB9lv48V1red8IE9Y2cqFgWcsqSF+NXZr55Vyr9e36SBrLyTlH2WJy6aMLWwC+BVxDmmQXYStKNwMFmtnDIBzvn3IYwSl5Nax4z27fVZXDOdag2iMWpTS7fAAaAF5rZtma2LfCiuO8bKRlImiDpekm3SrpD0npdFyRtL+mPkuZIulrSNnH/vpJuKWwrJf1LYtmdc21KlrZ1AklbSDpN0sWS/kfSqZKetwH5pMTiIyQ9UYi5R8b920v6e9x3h6Sj6/HcnHPlVvZYnFqZPQA4xszur+wws/nAcfFYilXAfmb2cmAXYJakvarSnAX8MM6OcBrwpXiuq8xsFzPbBdgPWA78PvG8zrl2ZYnbGCdpb2Ae8C5gBbASOByYJ+lVmdmlxGKAn1XirpmdF/c9CrwqxuI9gU9K2ir7CTnn2ksdY7GkWZLuljRP0idrHK/5Y3o4OX1maxUz+WvEzIy1Cy/0xq368TMJK90AXAX8qkZWhwC/NbPlqed2zrWnTml1TXAWcCFwtJkNAkjqAr4DfAV4dWpGibF4qMcWOwaOJ71BxDnXxuoViyV1A+cSGkIXADdIutTM5lYl/ZmZHZuab2og+iPwTUnbFgq0HfC1eCyJpG5JtxBWFLuixvK4twJvi7cPBjaStFlVmkMJQX2ocxwl6UZJNw4sWZZaNOdcGXnLbMUuwFcqFVmAePtsYNfczBJiMcDbY5evi6ti/7aS5gAPA6fXGjPhcdi5MaZ+sXgPYJ6ZzY8/ji8CDhpt8VIrs8cBk4H5kh6MCyfcF/clTwljZgPx8tQ2wB6SXlqV5CTg9ZJuBl4PPELolwuApC2BlwGXD3OO2Wa2u5nt3r3x5NSiOefKJjV4dkZl9llghxr7dwCeyc0sIRb/P2BG7PJ1BfCDwmMfjvtfCLxP0hY18vc47NxYkReLp1d+yMbtqKrctib8EK5YEPdVq/ljeiip88w+LGk34A2snRbmTjP7Q8rja+T3jKSrCGuN317Yv5DYMitpCvB2M3um8NB/BX5pZnnzazjn2o5o6ExK7eYi4HuSTgb+GvftDZzOMFeqRjJMLH6qkOw84Iwaj10o6XbgtfjCOs6NWZmx+Ekz232Up/x/wIVmtkrSvxF+TO833AOS+8zGflZXxC2bpM2Bvhg8JxL6S5xelWY68HS8fPYp4PyqbA6L+51znaAzWl1TnEz4PjmftXG7D/g2sN4AiuEkxuItzezRePdA4M64fxvgKTNbIWka8Brgqxv2lJxzbaN+sfgRoNjSuk3ct/ZUCT+mqyV33pf0L5KukfRk3P4k6eDUxwNbAlfFvlY3EPpp/TpONXNgTLMPcLeke4AtgC8Uzj+D8AL8X8Y5nXNtrOzTwTSLma02s+OBaYT+s7sAm5rZR6sGZaVIicXHxam3biV0JTsi7n8J8Le4//+As8zsttE8N+dc+dUxFt8AvEjSDpLGEcZBXbrOuUKX0oo1P6aHk7powseALwI/BC6Iu18F/FTSZ83srJHyMLM51BioYGanFG5fzBCXq8zsAWr3q3DOjVUlX3Wm2eIsLqOqPCbG4k9R4yqYmV0B7Dya8zvn2lCdYrGZ9Us6ljD2qRs438zukHQacKOZXUr4MX0g0A88zdof00NK7WZwEnCsmX23sO98SdcT5oMdsTLbCr09A/zD5s8mp1+xOn1pvBUb5y0XuGLChKz0z65IL8vkBelLEQJ0r8pryNFgA2sU3enLBVpv1urLDEzOW852+fT0sqzYOm+5wG23fWrkRAXbTHkmOe1gZs/Slf15S0Au609/ry/vy8v7geEOdkir63AkvZnQlWBnM1tSdWwTwgwwH4qVzHIaAFuW/tntWZH+fu5ZkfkGye2EnZN97jLR4zKXs12R/ho+tzIv9j07Kf37aXFv3vdNzvK0ACu70mNIb1feUu6TujKXnM1YLndZ5vK0G2cuxZuz/O2yzGV7R1TnWGxmlwGXVe0b8cf0cFK7GUwhzPta7ap4zDnn6q/kE3U3wbHAmdUVWQAze5bQ1/WEZhfKOddhSj6zTGpl9leExQqqvZ2qvg7OOVcv9eqnVZio+82ExVkOkzSzRtJaq1610s7AcLPGXAm8vEllcc51qLKPX0i9bjGPsGzhvsC1cd9ecTtbUmXVLszs7PoW0TnXseoXHNdM1A0gqTJRd/WqM2WzOcP3VjOgemEZ55yrr5J3+UqtzB4BLAZ2jFvFYuD9hftGWJHGOedGLeOX/nRJNxbuzzaz2YX7tSbq3rNGPm+X9DrgHuCjZvZwjTTNtIDQOnvvEMd3pmpaG+ecq7eyj19IXTSh1sozzjnXOHl9sFoyUXcT/Ab4T0mXmdmK4gFJkwgDcH/TkpI55zpDG6y0mDc83DnnmqnkE3U3wRcI4xXukXQOcFfc/xLC4DARpk10zrnGGSuV2bhAwr7A86gaOGZm/1rncjnnOpyo66WtNRN1EyqxhwLvWud8Q6x61UpmtkjSqwnTc32RtZNLGWGexmPM7PFWlc85N/bVORY3ROqiCV8BPgL8BXgcyJtk0znnNkSdAmijJupuBjN7EHhLXD72hYTvlnvNbHFrS+ac6xhjoTILvA94h5n9byML45xzaxhosH4RtBETdTeSpB3M7P7K/Vh5vWGItAK2KcGANefcWFPnWNwIqfPMLmdtXy3nnGuKss9t2GDXSvqepFcNlUDSNEkfJkwxdlDziuac6yRlj8WpLbNfBk6W9G9mlrd+nHPObaixW1FNsRPwaeA3kgaBm4CFwEpgGmHxh5cA1wMnmNnlrSqoc26MK3ksTq3Mfhf4Z+ARSfcA6yz8a2atnr6mpvHd/bxgkyeT0y/tS1/P+tnVE7PKsqgnr5vx8mc3SU67cvP0dbUBJi3Om8RC/RllHxxufvdamWesT96bV+6BSXnpV01LL8ukrZZm5f3GLfPGEu0w/onktM8M5K2Vvqhv46z0T61OX7F6SX/emvDXjXB8DLe6jsjMngE+LukU4K3Aa4DtgYnAk4Spwy43s9tbVsgUg6Lnue7k5L0ZH63eZZlvkIxwk0uZoW+wN68w3ctSL6TCshXjsvJevCo9hkzqWZ2Vd39P+v8eYEVXb3Lanq68F31CV9/IiQomdaU/1yndK7PyXpnxPAEmd6XH1gkZ5U5V9lic+m3/HUIg/R1hAFjJn5ZzbkzwSEOcX/biuDnnXPOVPBanVmbfCRxsZlc0sjDOObfG2O4P65xz7aENYnHqdYsn8CUTnXPNZolbB5E0UdLWNfb/YyvK45zrACWPxamV2c8Bp0lK7zznnHOjUJmou8wjaJtN0iHAvYRBYXMk7Vk4/KMWFcs5N4a1QyxO7WbwcWAG8Likh1h/ANjOdS6Xc86BdVBNNc1ngFeY2eOSXgH8QNIXzeynNHR4k3Ouo5U8FqdWZn3ggXOu6Tqp1TVRb2X5WjO7SdLrgF9KeiEd1+HCOdcsZY/FSZVZM/t8owvinHPrMJAvnF1tkaSdzWwOgJk9LekAwjRdfoXMOVd/bRCLsybilLQfYaJuA+4ws6sbUSjnnAO8rXF97wHWWbjGzFYDh0k6pzVFcs6NeSWPxUkDwCRtLel64ArgE8AngT9K+pukrRpZQOdc5yr7oINmM7MFZvbYEMf+0uzyOOc6Qz1jsaRZku6WNE/SJ4dJ93ZJJmn3kfJMbZn9BjAAvNDM7o8neT7w43jskMR8nHMujVH6QQfNIun8IQ4ZYXnbecDPzGxh80rlnOsIdYzFkrqBc4EDgAXADZIuNbO5Vek2Ao4H/paSb2pl9gBgn0pFFsDM5ks6DvhjYh7OOZelk1pdR7A58FpgEKgsX/tSwgwGNwFvI0yf+Fozu6UlJXTOjVl1jMV7APPMbD6ApIuAg4C5Ven+EzidMJvWiHL6zNZ6KqX+qhnXNcB2Excnp3+mJ2d96rw1nnPN3zS9LCs2y1vjeVJvVldpWLo8OakN5K2Vre6MdbuVN/PQwLj0tcwB+tNfcmZu/nhW3m/eaE5W+qkZa2s/MpA3/fPD3ZtlpX+8e5PktE/3T87Ke0SljjBN9RdgKfBBM1sOIGkS8F3gVuAtwA+BrwD7t6qQtWgAep9L/+z2Lk3/p/cuz3yD5E5elpG98kIfg5lhuG9ZeuFXrcj7TliyckJy2sm9GYES6B/MiPHA+O7+kRNFPZkv+viu9LwBlnenx+Hlg+My885LPynjO2Fy16qsvJOkfxamS7qxcH+2mc0u3N8aeLhwfwFQnC8bSbsB25rZbyTVtTL7R+Cbkg4zs4fjybYDvoa3zDrnGqAyUbcDwuW2/SoVWQAzWy7pC8AfzewMSacDf2hZCZ1zY1JmLH7SzEbs4zrkuaQu4GzgiJzHpTZdHQdMBuZLelDSg8B9cd9xOSeU1C3pZkm/rnFse0l/jCvbXC1pm8Kx7ST9XtKdkuZKmpFzXudcmzFL38a+KcCWNfb/QzwGsISMq20jxOLXSfq7pP646ljxmMdi5zpJfWPxI8C2hfvbxH0VGxG6UF0t6QFgL+DSkQaBpc4z+3Bs9n0DsFPcfaeZbUgrwPHAncDGNY6dBfzQzH4QpwH7EmEqGgiX0L5gZlfEZXUzL+o459qNt8yu8Uvge5JOBm6I+14JnAFcEu/vAdyTkedwsfghQsvISTWOeSx2rsPUMRbfALxI0g6ESuyhwLsqB83sWWD6mvNKVwMnmdmNDCP5V7yZGWFqriuyil0QW1rfCnwBOLFGkpmF/VcBv4qPmwn0mNkVsSxLN7QMzrk24pXZiqMJl95+zNq43Q+cz9oK553Ah1IyGykWm9kDMd1g1eM8FjvXieoUi82sX9KxwOVAN3C+md0h6TTgRjO7dEPyHbabgaQ3S3pA0nq/3CVtEo8dkHG+rwEnM/Qv+VsJo3IBDgY2krQZsCPwjKRL4mWxM+P0DrXKfJSkGyXduHxxAzpBO+eaxueZDcxsuZkdDWwK7Bq3Tc3sw2a2LKa5JWMmg68xfCweSlIsLsbhgeXLMk/hnCubesZiM7vMzHY0sxeY2RfivlNqVWTNbJ+RWmVh5D6zxwJnmtmSGid4ljBtwgkphZf0T8AiM7tpmGQnAa+XdDPwekIT9AChJeK18fgrgeczROdgM5ttZrub2e6Tpo1PKZpzrowMGLC0rUOY2TIzmxO3DaolJsbioSTF4mIc7p5U5xkunHPN1QaxeKTK7M4MPzr2SuDliefaGzgwdui9CNhP0o+LCcxsoZm9zcx2BT4d9z1DmLrhFjObb2b9hO4HuyWe1znXprxldi1JW0g6TdLFkv5H0uclbbEBWY0Yi4fhsdi5DlT2WDxSZXZzhr8MZUDSpJVm9ikz28bMZhA6/F5pZocX00iaHqdlAPgUoT8YhA7DUyVtHu/vx/oT7Drnxpo6zmbQiCUUm0XS3oRVvt4FrCCs+vVu4F5Jr8rJKyUWD8NjsXOdqOQzy4xUmV1AaJ0dys6sO6VCttjScGC8uw9wt6R7gC0IgxMwswHCZa0/SrqNMO3Zd0dzXudc+dWrNaCwhOKbCQNND4uDmarTZS2h2ERnARcCO5rZe8zsPYT+qxcRFkoYtWIslvRKSQuAdwD/LekO8FjsXKcqe8vsSLMZ/Ab4T0mXmdmK4oG4+sxpMU0WM7sauDrePqWw/2Lg4iEecwXDV6ydc2OJUc/ZDBqyhGIT7QIcYWZrrpSZ2aCks4GbNzTTYWLxDYT5H2s9xmOxc52kvrG4IUaqzH4BOAS4R9I5wF1x/0sIg8MEfLFxxRudbgbZqHtlcvpVGesLLhvIW4quK/cnS8ayi5a3WiBkLjlrK9Nfw9zlbBkcSE6qcXlLNHavbtz0l1tNfDYr/Uvyik6vJmakzpsdaeVgXmH6Mt5gOWlHEladSf7ctGQJxSZ6FtgBuLtq/w7AM00vTQYNQm/GW3Tcc+mxsve5vOVJrTtvPducsC3LWz7buvLSr16Wnn718ry1cpetTP8+WzIufelbgP7BvOc5riv9O6Ercznbcd3peYeypA8in9KTvtwsbMBythlL6+YsfZsiMxa3xLDveDNbJOnVwLcJldZKJDDCHGHHmFneIvXOOZcq/buqJUsoNtFFrF004a9x396EVuQLW1Yq51xnKPnSKCP+fDOzB4G3SJoGvJBQob3XzBY3unDOuc5Wx9aAnCUUISwTe6mkA1PmOGyCkwmx93xC3BawmtDQMORgNuecq4e2bpktipXXG0ZM6Jxz9VDffloNWUKxWcxsNXC8pE8BL4i77zOz5S0slnOuE4yBPrPOOdci9ZvqpVFLKDaSpBHLFFuRMbMDR0jqnHMbqLXTbqXwyqxzrrQ0WL8AamaXAZdV7TtliLT71O3EG+6pVhfAOeegvrG4Ebwy65wrJwsj4TuVmb2/1WVwzrl2iMVemXXOlVfJL20551xHKHks9sqsc668yh0/nXOuM5Q8Fntl1jlXWmWfDsY55zpB2WOxV2adc+VV8gDqnHMdoeSx2CuzzrlyMkq/6oxzzo15bRCLx3Rl1lDWWvGrBtNfjmX9eesqL12dl14r0sudO8pQfXnrmQ+sWJmROG/ta/r60tN2pb8mAL1PT85KP35x+jrcC1dskpV3t/LWhO9V+nPNW/k832pL/1zkfN5GIqz0l7bcyDQAvUvT/4+9y9IDWs/yvFhG5ucwy2Dee9+6MmPCsvS0XcvzosKqlb3JaZ8bn/dd1j+YV5aervT/f3dGWoCezC/L3u7077PlmXWCST156af0rE5OO64r83MxgnaIxWO6Muuca3MlD6DOOdcRSh6LvTLrnCuvkgdQ55zrCCWPxY2+QumccxvGQAOWtDnnnGuQOsdiSbMk3S1pnqRP1jh+tKTbJN0i6c+SZo6Up1dmnXPlZZa2Oeeca5w6xWJJ3cC5wJuBmcBhNSqrPzWzl5nZLsAZwNkj5euVWedcSSUGT6/MOudcA9U1Fu8BzDOz+Wa2GrgIOGids5ktKdydTMKSDd5n1jlXToZXVJ1zrtXyYvF0STcW7s82s9mF+1sDDxfuLwD2rM5E0jHAicA4YL+RTuqVWedceZV8bkPnnOsI6bH4STPbfbSnM7NzgXMlvQv4DPC+4dJ7ZdY5V1pln9vQOec6QR1j8SPAtoX728R9Q7kI+PZImXqfWedceXmfWeeca736xeIbgBdJ2kHSOOBQ4NJiAkkvKtx9K3DvSJl6y6xzrpwMGPSKqnPOtVQdY7GZ9Us6Frgc6AbON7M7JJ0G3GhmlwLHSnoD0AcsZoQuBuCVWedcaXmrq3POtV59Y7GZXQZcVrXvlMLt43PzHNOV2X7rYnHfpOT0T66akpz2qZWTs8ry9JK89N1L03uA9KzIHCWzui8rufVlrPM8mL6WNYBl/NrrWr48K+/uxc9lpZ/yaPr/f86CrbPyvn2bvECwVffS5LRPDI7PyvvpgfTnCfDswMTktDmftyRemW17GoTeZen/x96l6TGke3lmLJOy0ud0xMv9MrWevF5+PcvT03evzCvL6pXdyWlXTBiXlffgYN7z7OpK/z7r7sqLD13KS9+TUZbxPb1ZeS/vz3sdl/esTk47rivvezhJyWPxmK7MOufamAEDPp2Bc861VBvE4qZWZiU9ADwHDAD91dM3SJoGnA+8AFgJfMDMbk95rHNurDGwcgfQdhZX4rkReMTM/qnq2FeBfePdScDzzGxqPHY6YVAGwH+a2c+aU2LnXGuUPxa3omV2XzN7cohj/wHcYmYHS9qJsOTZ/omPdc6NNSW/tNXmjgfuBDauPmBmH63clvQRYNd4+63AbsAuwHjgakm/rVqxxzk31pQ8Fpdtaq6ZwJUAZnYXMEPSFq0tknOuJSojaFO2BJJmSbpb0jxJn6xx/GhJt0m6RdKfa6wXPmZI2obQunpeQvLDgAvj7ZnANWbWb2bLgDnArMaU0jlXCnWOxY3Q7MqsAb+XdJOko2ocvxV4G4CkPYDtCRPqpjyW+LijJN0o6cYVi1fVufjOuaaq09yG8ZL6ucCbCRWyw2pUVn9qZi8zs12AM4Cz6/xsyuRrwMmMsK6PpO2BHYiNDIQYPUvSJEnTCV0Rtq3xuDVxuH/lsroW3DnXAiWf87vZ3QxeY2aPSHoecIWku8zsmsLxLwNfl3QLcBtwM6GPbMpjAYhrAM8G2GLmpuVuF3fODa9+wXEPYJ6ZzQeQdBFwEDB37anWuVQ+mfADesyR9E/AIjO7SdI+IyQ/FLjYzAYAzOz3kl4J/BV4AriWtTF6jWIcnrzZtmPydXSuo3g3g7XM7JH4dxHwS8IXTPH4EjN7f2wZeS+wOTA/5bHOubEmsSUgBNnplZbAuFVfvdkaeLhwf0Hctw5Jx0i6j9Aye1yjnlmL7Q0cGAfVXgTsJ+nHQ6Q9lLVdDAAwsy+Y2S5mdgAg4J5GFtY512pZsbglmlaZlTRZ0kaV28Abgdur0kyNy5sBHEnom7Uk5bHOuTHGgMHBtA2eNLPdC9vsDTql2blm9gLgE8Bn6vhsSsPMPmVm25jZDEJl9UozO7w6XRyEO43Q+lrZ1y1ps3h7Z2Bn4PdNKbhzrjXyYnFLNLObwRbALxUmre4h9E/7naSjAczsO8BLgB9IMuAO4IPDPbaJZXfOtUL9fuk/wrp9O7eJ+4ZyEfDtep28HVQtJwmhonuR2Tr/hF7gTzEWLwEON7OMVVWcc22p5N0MmlaZjX3VXl5j/3cKt68Fdkx9rHNujKtfAL0BeJGkHQiV2EOBdxUTSHqRmd0b774VuJcxzsyuBq6Ot0+pOnZqjfQrCQPonHOdxCuzrdNn3Ty6cpPk9I+v2Cg57aLn8pYEXb14Qlb6Sc+kL7vYu6yxTfvqSi9L9rzKGcvfWu4yvEvzRlFPWrgiOW33nXn//1/slLfGx94bpXdDfKo/ryyP9k3LS786/TO0aGX6Z2hEZthAfZZlNLN+SccClwPdwPlmdkdVa+Sxkt4A9AGLgffV5eQdToNG7/KMJUqXpzf0akX6Ep+QF8vCAzLSZy6V29OTmT5jydnulXk9CLUqPe/VqxtbbVDGkrO5qxPn5A15y9+u6M57Xcb15MW25d3py9+O767zxZI6xuJGGdOVWedcm6vjvIVmdhlwWdW+Uwq3j6/byZxzbixp4RyyKbwy65wrr5Jf2nLOuY5Q8ljslVnnXDmZtXR0rHPOOdoiFntl1jlXXiVvDXDOuY5Q8ljslVnnXGlZyVsDnHOuE5Q9Fntl1jlXUq1dUcY55xy0Qyz2yqxzrpyM0o+gdc65Ma8NYrFXZp1z5ZU9cbFzzrm6K3ks9sqsc66UDLCStwY459xY1w6x2CuzzrlyaoNVZ5xzbsxrg1jslVnnXHmV/NKWc851hJLHYlnJR6iNhqQngAerdk8HnmxBcWrxstTmZaltLJZlezPbvNYBSb+L50nxpJnNqkN5XJ0NEYdhbL6f68HLUpuXpbZ6lGXIOAztEYvHdGW2Fkk3mtnurS4HeFmG4mWpzcvixpIyvYe8LLV5WWrzspRPV6sL4Jxzzjnn3IbyyqxzzjnnnGtbnViZnd3qAhR4WWrzstTmZXFjSZneQ16W2rwstXlZSqbj+sw655xzzrmxoxNbZp1zzjnn3BjhlVnnnHPOOde2xmxlVtIsSXdLmifpkzWOj5f0s3j8b5JmNPn820v6o6Q5kq6WtE3h2OmSbo/bO0dZjvMlLZJ0+xDHp0n6ZSzH9ZJeWjj2UUl3xHJcKGnCKMuyraSrJM2N+R7fqvJImhDzvzXm+fkaaWr+jyTtK+kWfyoQAAATw0lEQVSWwrZS0r9saFlint2Sbpb069RyxGPbSfq9pDvj6zpjNOWIeT4g6bb43G6scXy4/9Gwj3WdJSH+SNI3YpycI2m3Zp4/ptknvl/vkPR/cd+I8WEDypIS/94dX4fbJP1V0ssLx6ZKuljSXfHz/qoGl2UTSf+v8Bq8v3Csnt9RKbH4CElPFGLukXH/9pL+Xvj/HT2assQ8h4vFr4vn65d0SNWxRsTi4cry1cLrcY+kZwrH6vb/aRtmNuY2oBu4D3g+MA64FZhZlebfge/E24cCP2vy+f8HeF+8vR/wo3j7rcAVhNXZJgM3ABuPoiyvA3YDbh/i+JnA5+LtnYA/xttbA/cDE+P9nwNHjPJ12RLYLd7eCLinxuvSlPIAAqbE273A34C9Uv5HVWk2BZ4GJo3ytTkR+Cnw6xrHhiwHcDVwQLw9ZbTliPk8AEwf5njN/1HKY33rrC0h/rwF+G38PO4F/K3J558KzAW2i/efF/+OGB82oCwp8e/VwLR4+83F1wP4AXBkvD0OmNrgsvwHcHq8vXmMc+Oo/3dUSiw+AjinxmPHAePj7Skx/mw1yv/TcLF4BrAz8EPgkKpjjYjFQ5alKt1HgPPj7br+f9plG6sts3sA88xsvpmtBi4CDqpKcxAhOABcDOwvSU08/0zgynj7qsLxmcA1ZtZvZsuAOcAGr6ZhZtcQgtBQ1pTDzO4CZkjaIh7rASZK6gEmAQs3tBwx/0fN7O/x9nPAnYRKatPLY8HSeLc3btWjIYf6HxUdAvzWzJZvaFliS+tbgfOGSFKzHJJmAj1mdgWAmS0dTTkyDPc/cm6NhPhzEPDD+Hm8Dpgqacsmnv9dwCVm9lBMvyj+TYkPuWUZMf6Z2V/NbHG8ex1QuRq0CaFi/r2YbrWZPdPIshCe70bxe3EK4XXsp/7fURv8WsfXYVW8O55RXm0eKRab2QNmNgcYrHpc3WNxwvdC0WHAhfF2Xf8/7WKsVma3Bh4u3F/A+h/UNWnMrB94Ftisiee/FXhbvH0wIWhsFvfPkjRJ0nRgX2DbOpWrljXlkLQHsD2wjZk9ApwFPAQ8CjxrZr+v10njJZhdCb/CW1KeeAnnFmARcIWZDVkW1v0fFR3K2iCyob4GnExVgEwox47AM5IuiZeizpTUPcqyQPgi+b2kmyQdNVx5iv+jxMc6V5QSKxtpR2CaQvedmyS9t3IgIT5ssGHiX9EHCa3WADsATwDfj5/18yRNbnBZzgFeQmg0uA043swGacB3VOJr/fbYBeNiSdsWHrutpDmE99HpZjaaRpevMXwsHkojYnFSWSRtT3h/VBo8ml2HKIWxWpltBycBr5d0M/B64BFgIFbQLgP+SqgkXQsMNLAcXya0htxCuFRxMzAgaRqh1WQHYCtgsqTD63FCSVOAXwAnmNmSVpXHzAbMbBdCRWwPFfp+RjX/R4XnsSXwMuDyDS2DpH8CFpnZTcMkG6ocPcBr4/FXErq1HLGhZSl4jZntRrjMeYyk11Udr/k/Snysc2XSA7yC0AL2JuCzknaEpPiwQUaIf5U0+xIqs58olHM34NtmtiuwDFhvLEady/Im4BZCvN0FOEfSxo34jkp4rf8fMMPMdiZcQv9B4bEPx/0vBN63oVeJEmPxUOoaizPLcihwsZkNALSgDlEKY7Uy+wjr/hLZJu6rmSZett4EeKpZ5zezhWb2thiYPh33PRP/fsHMdjGzAwj9ie6pU7nWY2ZLzOz9MZC8l9A3aj7wBuB+M3vCzPqASwj9uUZFUi8heP7EzC5pdXniOZ8hXL6fVbV/yP9R9K/AL2N5NtTewIGSHiB0R9lP0o8Ty7EAuCV2Z+kHfkX4whuV2ApeueT6S0K3meLxof5HIz7WuSopsbqRFgCXm9kyM3sSuAZ4eTHBUPFhQ4wU/2KanQmXlg8ys8p30gJgQaHF8mJG+VlPKMv7CV0wzMzmEcYs7ASN+44aJhY/VehOcB7hB0j1YxcCtxMqlRtixFg8jHrH4pyyrHd1sJl1iLIYq5XZG4AXSdpB0jjCP/vSqjSXAu+Ltw8BrjSzeq0gMeL5JU2XVHn9PwWcH/d3Vy5lx6C2M1C3y/vVFEbIjot3jyT0tVlCuJy/V7xUIWB/Qr+q0ZxLhD5fd5rZ2a0sj6TNJU2NtycCBwB3VaWp+T8qKPZT2iBm9ikz28bMZhDeJ1ea2TotzsOU4wZCC+nm8f5+hMEsG0zSZEkbVW4DbyR8QRTT1PwfpTzWuSqXAu9VsBeh+9CjTTz//wKvkdQjaRKwJ3BnSnzIlRj/tiP8UH+Pma2pgJjZY8DDkl4cd+3PKD7rKWUhxNz9Y/otgBcD8+v9HZUYi4v9qA8kxn5J28THEK/evQa4e0PKkRKLh1HXWJxaFkk7AdMIra+VfU2tQ5SGlWAUWiM2wijZewizCnw67jsNODDenkAYJT4PuB54fpPPfwhwb0xzHmtHZE4gfAjmEgYA7DLKclxI6GPaR/j1+EHgaODoePxVsQx3E4LotMJjP08IKrcDP6qUcRRleQ2hT+UcwuWrW+Lr1PTyED7gN8ey3A6ckvo/isdmEFqQuur4ntmHOGo1oxwHxOdwG3ABMG6UZXg+oc/VrcAdhffuiP+joR7rW+duCfFHwLmEOHkbsHszzx/TfJwQb28nXG4fMj6Msiwp8e88YHHh+I2Fx+8C3Bgf/6tibGxQWbYiVIJui6/B4XF/vb+jUmLxl2JMuZXQcrtT3F+Jf7fGv0fV6X2zD7Vj8Svj+2gZ4UruHYXH1DUWj1SWeP9U4MtV6ev6/2mXzZezdc4555xzbWusdjNwzjnnnHMdwCuzzjnnnHOubXll1jnnnHPOtS2vzDrnnHPOubbllVnnnHPOOde2vDLr3ChJekDSSa0uh3POOdeJvDJbUpK2kPR1SfdJWiXpEUm/lfSWVpetTCTNkGSSdk9I+2lJf5G0TJLPSeecc86NAV6ZLSFJM4C/E9bG/hRhUuk3AL8BvtO6krW98YRJ/r/W4nI450pI0gWSft3kc06T9LikFzTzvK4xJP2PpI+1uhydxiuz5fSt+Hd3M/u5md1tZnea2TmEii0Qlj6U9EtJz8XtEknbFI6fKul2Se+Ll8KXSfq+pHGS/l3Sw5KeknR2YbnUymXzUyX9WNJSSY9VX0bPOPehsXX5OUm/kjS9Kp/3S5oraaWkeyR9tKosJumoGCCWSZovqbis3/3x7w0x7dVDvahmdoqZfYWw2kwSSVdL+k5sJV8ctzOLZYwmSPpvSUskLZD08ap8TpQ0Jz6HRySdV1nCMR7fRNKPJC2Kr8V8SSdUHZ8djz8n6f9SWqOdc6X3H8BlZnZfZYdfmUsXY/Q5wxx/naRL42toko4YJu3mkr4VvwNXxR8Zf5R0QCHNBTGf6m2XmOQ04NOSNqnXc3Qj88psyUjaFJgFnGtmS6uPm9kzMV0XYV3xLYB947YV8CtJKjxkBnAQ8E/A24B3ENZDfyXwRuBI4CPAwVWnOpGw/vVuwOeAL0p62wac+50x7zcCuwJfKDzXDwFfBE4BXgJ8DPgE8O9VZTklnu/lwM+A8xXWMAfYI/6dBWwZn2O9vZvwWXkV8G/AUcAJVWk+SljGcDfgdOAMSa8qHB+Mj/lH4F2x3N8sHP8v4GWE/9OLgQ8QlsutrKP+G2DreHxX4BrgSq27Zrlzro1ImkSIwd8r7JuBX5mrpymEZXKPB1aMkPYXhNj8QWBHQrz9LbBZVbo/EL5vitvtAGZ2GzAfOBzXPK1eT9e3dTfCB8mAg0dIdwAwAMwo7Hs+odL0hnj/VMKHd5NCmouBJyisGw1cDZxTuP8AcEXV+c4D/px57pVV5/40MK9w/yHgPVXnOQGYW7hvwJcK93uA5axdJ3xGTJO8pjtwSHjrJ6W9GrgHwtLPcd9ngAVVr9eFVY+7F/jMMPnOAlYBXfH+pcD5Q6TdD1gKTKzafwtwcqvfs775NlY24ALg1/H2eEKXpMdjLLsOeE1V+snAD+Pn83FC5fPXwAWJ5zsEeLoqvlxG+CE7pUb6qYXbw5Yvxq5vA1+J53iCUKEbD5wLPDNEDL6aUGn+OrA4bmdWYlXGa3M14SrjF4EngUXAWYWYJ+Bk4D7C99RtlbiekccFhPhf3GYM83ovBY4Y4tjU+Pg3pL5HhklzCvH70rfmbN4yWz4aOQkQWjIXmtkDlR1mNh9YCMwspHvIzJ4t3H8cuMfMVlfte15V/tfWuF/JN/XcD1ade2HlPJI2B7YF/jt2ZVgqaSnwZaC679icwnn6CUG5uryNdJ3FCBVdC2wtaePCvjlVj1nzXAEk7SfpitgF4TlC391xwD/EJN8G3inpVklnSXp9Ia9XAJOAJ6peq5ey/mvlnKuPMwhXlj5AuBpyG/C7qqshXwFeT7j6tB/h6tFrM87xWuCmSnxJvTKXUb53A88BexJi69eAXxF+oO8O/AA4r8YVnpGuRqWcu5JPP/Bq4NiYxzvjsf8itIAeQ/je+BLh++CtGXkcT4jH32dtC+nDbJilcTtQ0oQNzKPiemAPSRNHmY9L5JXZ8rmX8OvwJaPIo1jx6qtxrNa+er0XRjp35TyVv0cDuxS2lxIuxRc1srz1MmQZJW1PuER4J6GbxysIXwIQKrSY2W+B7QmtDtOB30j6fkzTRfjBsUvVthPw2fo/Fec6m6TJwIeBT5jZb8zsTkKsepxQ+ULSFMLn+BNmdoWZ3UGonA0W8tk29umcG/vMv6PqVNsTfvhWvJDQoHHnaMsX3WFmp5rZvcDZhNbNPjP7upnNI/TvFLB31SkeBY4zs7vM7OeEltkTM88N4SrbKWZ2T8znKmD/mMeJwJFm9jszu9/Mfgp8NzUPgNhYshpYbmaPxW1guNduKLGh5AhC94BnJF0bGxb2rJF8VrFhQdJvq44vBHoJ3e9cE5StQtDxzOxp4HLg2Bgs11EYNHQnsFXsX1U59nzCh2duHYqyV437lQA76nOb2eOED/wLzGxe9ZZRzkoLc3fGY3LtWdUXeC9Cy/SSxMfvTqi0ftTMrjWze6gR5MzsSTP7kZkdQfhSfJ+k8YT+c1sAgzVeq0WjeWLOuZpeQKiM/KWyI1aSileoKmmuL6RZRuw7GfUDJ5jZTMK4ga/FilzFRMJl+orUK3Mp5YN1r2oZ4TL9bYV9fYRuBNVXuoa7GpV67nXOH1WuWM0EJhBac4tXmz7MMFfmqvKoOzP7BSE2/zOhr+yrgesk/UdV0mtYt2HhyKrjlb653jLbJD2tLoCr6RhCoLhR0mcJH2YRBlp9CtiO0AF9DvATScfHx32TUPG5sg5l2EvSpwh9bPcB3ku43EMdz/054JuSniH0E+slDKDa2sy+lJjHIkLgeJOkB4CVVV0b1oiDxjYl9LOlMPp0Xq1LegVbEb6EvkUYpPVxwiWyVPcSfjieIOkSQmX4hKqynUZ4/e4gfC7fBsw3s1WS/kB4P/yvpJOBuwjdE2YBfzCzP2WUxTk3OslzVJvZo4RWTszsMUlPEmLQspjkSWBa4SHFK3O/rEP5WnllbqjzdxXO98+EfrvDPaapV+bMbCVwRdxOk3QecKqkswrd85aP0Oiyafz7RKPK6dblLbMlFPuf7kb4MJ1OqDheCRxI6LtU+ZV9EOHDclXcHgP+peoX9YY6mzCK9mZCxe0UM7u4nuc2s/MIl+neA9wK/Ck+v/uHe1xVHv3AcYRfxgsJsx4M5bT4fM6M92+O20hTXP2E0PL7N8JlsO8BX80o4xxC364TCS3XRwLVK4atIsz0cCuh4roRIdBXXu+3EN4D3wXuBn5OmPVgIc65eruPcNVnzeV3Sd2EPqRzC2n6CDPDVNJMInSVWo+kVwDdZlbs03kzhdbMjCtzKeUbjeGuRtXj3HMJMW/7GlebHsws62oae2VuLqGBIacf7UuBR+IVSNcM9R5R5lv7b4TR+Se1uhxl2Kia6cE333wbuxvrzmbwNUKr6lsILaWzCQOEtiyk/06Ml/sTKqU/BZ4Fvl+V76aEqy6vrtr/MsLMMJsV9j0/nvcuQh/7FxP6x3+YMKCXlPLVil2ELhCnVu17DDi2cP9qwqCxr8dzH0KY+eCk1HMPc/7i6/tfwFOEBo0XEi7XHw0clZpHvD8buIlwxW06hVkX4vEprO0OsJww08AuwHZV6TYjNBgcTmjI2SG+/o9RmN2n+vzDvI++1+r3cydt3s3AOeecW98n4t/vE6ZtuhmYZaHrQMVJhOm5LiVU5r5K6N++ph9s7Pf+K+DLZvbX4gnM7DZJ1wOHEqbLwszmS9qNsJjC6YT5pZ8iXLU5KrN8G6p4NcpY/2pUPc79WcKgsZMIs7ksIUw3eEZmWc8izMowl9BHdQfCD4yK3QlXDys+H7cfEAZ8VSwlTDF2PKFyPZ4wRdpPyehWFmdCOJgwT7BrEsVfEc6tEfuenmNmZ7W6LK2msKLY7WZ2bKvL4pwrt1hxfRA408y+Ei/V/xS428xOHeIxswitoDNtA0fi15PHvNGRdAxwkJm9sdVl6STeMuvWY2YzWl2GsjCzfVpdBudcOUnalXCZ/XpCP/dPxL8/i0n2JsyJOkfSv8R977GwShQAZvY7SecC2xAqwq699RFW1XRN5JVZ55xzbsOdSOhb2k+4TP46M1sAYGZ/JmGgtZl9o5EFdM1jZrNbXYZO5N0MnHPOOedc2/KpuZxzzjnnXNvyyqxzzjnnnGtbXpl1zjnnnHNtyyuzzjnnnHOubXll1jnnnHPOtS2vzDrnnHPOubbllVnnnHPOOde2/j9CNzeKmGBA7wAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", - "\n", - "fig, axes = plt.subplots(len(keys), 2, figsize=(10, len(keys)*4))\n", - "for psi_act, lambda_act, axis in zip(all_psi_acts, all_lambda_acts, axes):\n", - " im = axis[0].imshow(psi_act / psi_act.max())\n", - " axis[0].set_xlabel('Component 1 phase', fontsize=14)\n", - " axis[0].set_ylabel('Component 2 phase', fontsize=14)\n", - " axis[0].set_xticks(np.arange(20)[::3])\n", - " axis[0].set_xticklabels(np.round(psi_values[::3], 2))\n", - " axis[0].set_yticks(np.arange(20)[::3])\n", - " axis[0].set_yticklabels(np.round(psi_values[::3], 2))\n", - " divider = make_axes_locatable(axis[0])\n", - " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", - " plt.colorbar(im, cax=cax)\n", - "\n", - " im = axis[1].imshow(lambda_act / lambda_act.max())\n", - " axis[1].set_xlabel(r'$\\log_2(\\mathrm{Component\\/1\\/SF})$', fontsize=14)\n", - " axis[1].set_ylabel(r'$\\log_2(\\mathrm{Component\\/2\\/SF})$', fontsize=14)\n", - " axis[1].set_xticks(np.arange(20)[::3])\n", - " axis[1].set_xticklabels(np.round(lambda_values[::3], 2))\n", - " axis[1].set_yticks(np.arange(20)[::3])\n", - " axis[1].set_yticklabels(np.round(lambda_values[::3], 2))\n", - " divider = make_axes_locatable(axis[1])\n", - " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", - " plt.colorbar(im, cax=cax)\n", - "\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 328, - "metadata": {}, - "outputs": [], - "source": [ - "lambda_values = np.linspace(1, 5, 20)\n", - "f_ratio_values = 1/ (fori_values / fori_values[::-1])\n", - "rot_values = np.linspace(-90, 90, 20)" - ] - }, - { - "cell_type": "code", - "execution_count": 329, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", - "\n", - "fig, axes = plt.subplots(3, len(keys), figsize=(len(keys)*5, 12))\n", - "for act, axis in zip(all_psi_acts, axes[0]):\n", - " im = axis.imshow(act / act.max())\n", - " axis.set_xlabel('Component 1 phase', fontsize=14)\n", - " axis.set_ylabel('Component 2 phase', fontsize=14)\n", - " axis.set_xticks(np.arange(20)[::3])\n", - " axis.set_xticklabels(np.round(psi_values[::3], 2))\n", - " axis.set_yticks(np.arange(20)[::3])\n", - " axis.set_yticklabels(np.round(psi_values[::3], 2))\n", - " divider = make_axes_locatable(axis)\n", - " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", - " plt.colorbar(im, cax=cax)\n", - " \n", - "for act, axis in zip(all_lambda_acts, axes[1]):\n", - " im = axis.imshow(act / act.max())\n", - " axis.set_xlabel(r'$\\log_2(\\mathrm{Component\\/1\\/SF})$', fontsize=14)\n", - " axis.set_ylabel(r'$\\log_2(\\mathrm{Component\\/2\\/SF})$', fontsize=14)\n", - " axis.set_xticks(np.arange(20)[::3])\n", - " axis.set_xticklabels(np.round(lambda_values[::3], 2))\n", - " axis.set_yticks(np.arange(20)[::3])\n", - " axis.set_yticklabels(np.round(lambda_values[::3], 2))\n", - " divider = make_axes_locatable(axis)\n", - " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", - " plt.colorbar(im, cax=cax)\n", - " \n", - "for act, axis in zip(all_fori_acts, axes[2]):\n", - " im = axis.imshow(act / act.max())\n", - " axis.set_xlabel('f_ratio', fontsize=14)\n", - " axis.set_ylabel(r'$\\Delta Orientation$', fontsize=14)\n", - " axis.set_xticks(np.arange(20)[::3])\n", - " axis.set_xticklabels(np.round(f_ratio_values[::3], 2))\n", - " axis.set_yticks(np.arange(20)[::3])\n", - " axis.set_yticklabels(np.round(rot_values[::3], 2))\n", - " divider = make_axes_locatable(axis)\n", - " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", - " plt.colorbar(im, cax=cax)\n", - "\n", - "fig.tight_layout()\n", - "fig.savefig('/src/static-networks/my_notebooks/Figures/high_low/high_low_tuning.png')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 221, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.2 , 0.25274725, 0.31034483, 0.37349398, 0.44303797,\n", - " 0.52 , 0.6056338 , 0.70149254, 0.80952381, 0.93220339,\n", - " 1.07272727, 1.23529412, 1.42553191, 1.65116279, 1.92307692,\n", - " 2.25714286, 2.67741935, 3.22222222, 3.95652174, 5. ])" - ] - }, - "execution_count": 221, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lambda_values / lambda_values[::-1]" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", - "for ax, im, act in zip(axes.ravel(), images, acts):\n", - " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", - " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", - "for ax, im, act in zip(axes.ravel(), images, acts):\n", - " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", - " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 10, figsize=(30, 2))\n", - "for ax, im, act in zip(axes.ravel(), images, acts):\n", - " ax.imshow(im, cmap='gray', vmin=-2, vmax=2)\n", - " ax.set_title('{:.2f}'.format(act/np.max(acts)))\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(values, acts)" - ] - }, - { - "cell_type": "code", - "execution_count": 457, - "metadata": {}, - "outputs": [], - "source": [ - "thetas = np.linspace(bounds['lower_edge_theta'], bounds['upper_edge_theta'], 100)" - ] - }, - { - "cell_type": "code", - "execution_count": 459, - "metadata": {}, - "outputs": [], - "source": [ - "param['edge_theta'] = thetas[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 192, - "metadata": {}, - "outputs": [], - "source": [ - "groups, neurons, masks, meis, mei_acts, optcps, optcp_acts, optcp_params = (base.MEIMask * zd_deis.MaskFixedMEI * high_low.OptimalCombPlaid & 'search_range = 3 and best_activation < activation').fetch('group_id', 'neuron_id', 'mask', \\\n", - "'mei', 'activation', 'best_image', 'best_activation', 'best_params', order_by='group_id, neuron_id')" - ] - }, - { - "cell_type": "code", - "execution_count": 426, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "46" - ] - }, - "execution_count": 426, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "groups[sorted_idx[3]]" - ] - }, - { - "cell_type": "code", - "execution_count": 427, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6369" - ] - }, - "execution_count": 427, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "neurons[sorted_idx[3]]" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "metadata": {}, - "outputs": [], - "source": [ - "act_ratios = optcp_acts / mei_acts" - ] - }, - { - "cell_type": "code", - "execution_count": 194, - "metadata": {}, - "outputs": [], - "source": [ - "sorted_idx = np.argsort(act_ratios)" - ] - }, - { - "cell_type": "code", - "execution_count": 197, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.histplot(act_ratios, stat='probability')\n", - "plt.xlabel('OCP activation / MEI activation')\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 414, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8871019177769498" - ] - }, - "execution_count": 414, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_ratios[sorted_idx[800]]" - ] - }, - { - "cell_type": "code", - "execution_count": 416, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "138" - ] - }, - "execution_count": 416, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(act_ratios > 1).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 423, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 423, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(meis[sorted_idx[3]])" - ] - }, - { - "cell_type": "code", - "execution_count": 424, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 424, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(optcps[sorted_idx[3]])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 235, - "metadata": {}, - "outputs": [], - "source": [ - "mei, mei_act, mask, mask_x, mask_y = (zd_deis.MaskFixedMEI * base.MEIMask & 'group_id = 88 and neuron_id = 2588').fetch1('mei', 'activation', 'mask', 'mask_x', 'mask_y')" - ] - }, - { - "cell_type": "code", - "execution_count": 236, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 236, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(mei)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "rel = (zd_deis.DEIGoodRun & 'diverse_params = 62 and threshold_params = 1 and mei_params = 8 and mask_params = 2').proj()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "04-04-2021:23:55:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "04-04-2021:23:55:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "04-04-2021:23:55:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "04-04-2021:23:55:51 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", - "04-04-2021:23:55:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "04-04-2021:23:55:51 INFO configs.py 377:\t Using statistics source all\n", - "04-04-2021:23:55:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "04-04-2021:23:55:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "04-04-2021:23:55:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "04-04-2021:23:55:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "04-04-2021:23:55:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", - "04-04-2021:23:55:51 INFO configs.py 351:\t Found 4472 active trials\n", - "04-04-2021:23:55:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "04-04-2021:23:55:51 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", - "04-04-2021:23:55:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "04-04-2021:23:55:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "04-04-2021:23:55:51 INFO configs.py 806:\t Setting cuda=False\n", - "04-04-2021:23:55:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "04-04-2021:23:55:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "04-04-2021:23:55:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "04-04-2021:23:55:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "04-04-2021:23:55:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/src/static-networks/staticnet_invariance/high_low.py:200: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /pytorch/torch/csrc/utils/tensor_numpy.cpp:143.)\n", - " mask = torch.as_tensor(mask, dtype=torch.float32, device='cuda')\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:51 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:51 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "04-04-2021:23:55:51 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "04-04-2021:23:55:51 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "04-04-2021:23:55:51 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", - "04-04-2021:23:55:51 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "04-04-2021:23:55:51 INFO configs.py 377:\t Using statistics source all\n", - "04-04-2021:23:55:51 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "04-04-2021:23:55:51 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "04-04-2021:23:55:51 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "04-04-2021:23:55:51 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "04-04-2021:23:55:51 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", - "04-04-2021:23:55:51 INFO configs.py 351:\t Found 4472 active trials\n", - "04-04-2021:23:55:51 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "04-04-2021:23:55:51 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", - "04-04-2021:23:55:51 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "04-04-2021:23:55:51 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "04-04-2021:23:55:51 INFO configs.py 806:\t Setting cuda=False\n", - "04-04-2021:23:55:51 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "04-04-2021:23:55:51 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "04-04-2021:23:55:51 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "04-04-2021:23:55:51 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:51 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "04-04-2021:23:55:51 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "04-04-2021:23:55:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "04-04-2021:23:55:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "04-04-2021:23:55:52 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", - "04-04-2021:23:55:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "04-04-2021:23:55:52 INFO configs.py 377:\t Using statistics source all\n", - "04-04-2021:23:55:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "04-04-2021:23:55:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "04-04-2021:23:55:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "04-04-2021:23:55:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "04-04-2021:23:55:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", - "04-04-2021:23:55:52 INFO configs.py 351:\t Found 4472 active trials\n", - "04-04-2021:23:55:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "04-04-2021:23:55:52 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", - "04-04-2021:23:55:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "04-04-2021:23:55:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "04-04-2021:23:55:52 INFO configs.py 806:\t Setting cuda=False\n", - "04-04-2021:23:55:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "04-04-2021:23:55:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "04-04-2021:23:55:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "04-04-2021:23:55:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "04-04-2021:23:55:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 INFO configs.py 388:\t Ignoring input arguments: \"net_hash\", \"core_hash\", \"ro_hash\", \"shift_hash\", \"mod_hash\", \"train_hash\", \"data_hash\", \"group_id\", \"seed\", \"train_type\", \"schedule\", \"max_epoch\", \"loss_type\"when creating datasets\n", - "04-04-2021:23:55:52 INFO configs.py 363:\t Loading None dataset with tier=train\n", - "04-04-2021:23:55:52 INFO data_schemas.py 1337:\t Data will be (images,behavior,pupil_center,responses)\n", - "04-04-2021:23:55:52 INFO data_schemas.py 1340:\t Loading dataset group014-20457-5-9-0 --> /external/cache/static20457-5-9-preproc0.h5\n", - "04-04-2021:23:55:52 INFO configs.py 373:\t Adding stats_source \"all\" to dataset\n", - "04-04-2021:23:55:52 INFO configs.py 377:\t Using statistics source all\n", - "04-04-2021:23:55:52 INFO configs.py 245:\t Excluding \"\" from normalization\n", - "04-04-2021:23:55:52 INFO configs.py 337:\t Using stimulus.Frame as stimulus type for all datasets\n", - "04-04-2021:23:55:52 INFO configs.py 341:\t Stimulus sources: \"stimulus.Frame\"\n", - "04-04-2021:23:55:52 INFO configs.py 275:\t Using all trial from stimulus.Frame\n", - "04-04-2021:23:55:52 INFO configs.py 348:\t Selecting trials from stimulus.Frame and tier=train for dataset group014-20457-5-9-0\n", - "04-04-2021:23:55:52 INFO configs.py 351:\t Found 4472 active trials\n", - "04-04-2021:23:55:52 INFO configs.py 310:\t Loader sampler is SubsetRandomSampler\n", - "04-04-2021:23:55:52 INFO configs.py 312:\t Number of samples in the loader will be 4472\n", - "04-04-2021:23:55:52 INFO configs.py 314:\t Number of batches in the loader will be 75\n", - "04-04-2021:23:55:52 INFO configs.py 397:\t Subsampling to layer L2/3 and area(s) \"V1\"\n", - "04-04-2021:23:55:52 INFO configs.py 806:\t Setting cuda=False\n", - "04-04-2021:23:55:52 INFO cores.py 101:\t Ignoring input {'core_hash': '86e5871c1e9112ad5c408697c2ad7d4d'} when creating GaussianLaplaceCore\n", - "04-04-2021:23:55:52 INFO readouts.py 146:\t Ignoring input {'ro_hash': 'a206f6da6a16ea14081062a1e2436b48'} when creating SpatialTransformerPyramid2dReadout\n", - "04-04-2021:23:55:52 INFO shifters.py 55:\t Ignoring input {'shift_hash': '05c69a4aeaeea5e48fa8fc5e70181d67'} when creating MLPShifter\n", - "04-04-2021:23:55:52 INFO shifters.py 27:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:52 INFO modulators.py 47:\t Ignoring input {'mod_hash': 'a757e992ae449e3057ff1d512a51bd1e'} when creating MLPModulator\n", - "04-04-2021:23:55:52 INFO modulators.py 18:\t Ignoring input {} when creating MLP\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer0.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer1.norm.num_batches_tracked' setting to initialization value\n", - "04-04-2021:23:55:52 WARNING models.py 81:\t Could not find paramater 'core.features.layer2.norm.num_batches_tracked' setting to initialization value\n", - "Optimizing with seed = 0\n", - "Optimizing with seed = 1\n" - ] - }, - { - "ename": "TypeError", - "evalue": "conv2d(): argument 'input' (position 1) must be Tensor, not numpy.ndarray", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhigh_low\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOptimalCombPlaid\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/datajoint/autopopulate.py\u001b[0m in \u001b[0;36mpopulate\u001b[0;34m(self, suppress_errors, return_exception_objects, reserve_jobs, order, limit, max_calls, display_progress, *restrictions)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_allow_insert\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m \u001b[0mmake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 155\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSystemExit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/static-networks/staticnet_invariance/high_low.py\u001b[0m in \u001b[0;36mmake\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0mtensor_params\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbest_params\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'cuda'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 259\u001b[0m \u001b[0mbest_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptcp_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensor_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 260\u001b[0;31m \u001b[0mbest_activation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbest_image\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 261\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 262\u001b[0m \u001b[0mks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'edge_center_x'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'edge_center_y'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'edge_theta'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'theta1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'angle1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Lambda1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sigma1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'psi1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gamma1'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'theta2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'angle2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Lambda2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sigma2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'psi2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gamma2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/featurevis/featurevis/models.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,\n\u001b[0m\u001b[1;32m 65\u001b[0m self.neuron_idx] for m in self.models]\n\u001b[1;32m 66\u001b[0m \u001b[0mresps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresps\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# num_models x batch_size x num_neurons\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/featurevis/featurevis/models.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,\n\u001b[0m\u001b[1;32m 65\u001b[0m self.neuron_idx] for m in self.models]\n\u001b[1;32m 66\u001b[0m \u001b[0mresps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresps\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# num_models x batch_size x num_neurons\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/static-networks/staticnet/base.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, readout_key, behavior, eye_pos)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreadout_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0meye_pos\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshifter\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshift\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/static-networks/staticnet/cores.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_)\u001b[0m\n\u001b[1;32m 157\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeat\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0mdo_skip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ml\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mskip\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m \u001b[0minput_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mdo_skip\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mskip\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 160\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/src/static-networks/staticnet_analyses/utils.py\u001b[0m in \u001b[0;36mnamed_forward\u001b[0;34m(self, input, name)\u001b[0m\n\u001b[1;32m 451\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnamed_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 452\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmod_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_modules\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 453\u001b[0;31m \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 454\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod_name\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 455\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 890\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 891\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 399\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_conv_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 401\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mConv3d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_ConvNd\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36m_conv_forward\u001b[0;34m(self, input, weight, bias)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstride\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 394\u001b[0m _pair(0), self.dilation, self.groups)\n\u001b[0;32m--> 395\u001b[0;31m return F.conv2d(input, weight, bias, self.stride,\n\u001b[0m\u001b[1;32m 396\u001b[0m self.padding, self.dilation, self.groups)\n\u001b[1;32m 397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: conv2d(): argument 'input' (position 1) must be Tensor, not numpy.ndarray" - ] - } - ], - "source": [ - "high_low.OptimalCombPlaid.populate(rel)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "key = (high_low.OptimalCombPlaid.key_source & rel.proj() & 'group_id = 46 and neuron_id = 879').fetch1('KEY')" - ] - }, - { - "cell_type": "code", - "execution_count": 213, - "metadata": {}, - "outputs": [], - "source": [ - "images = []\n", - "for l in lams:\n", - " params = torch.as_tensor([0, l, 3, 0, 1], dtype=torch.float32, device='cuda')\n", - " image = generator.gen_gabor(*params).cpu().detach().squeeze().numpy()\n", - " images.append(image)" - ] - }, - { - "cell_type": "code", - "execution_count": 212, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", - "for im, ax, l in zip(images, axes.ravel(), lams):\n", - " ax.set_title(l)\n", - " ax.imshow(im, cmap='gray')" - ] - }, - { - "cell_type": "code", - "execution_count": 214, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", - "for im, ax, l in zip(images, axes.ravel(), lams):\n", - " ax.set_title(l)\n", - " ax.imshow(im, cmap='gray')" - ] - }, - { - "cell_type": "code", - "execution_count": 208, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(5, 10, figsize=(30, 10))\n", - "for im, ax, l in zip(images, axes.ravel(), lams):\n", - " ax.set_title(l)\n", - " ax.imshow(im, cmap='gray')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/featurevis/.ipynb_checkpoints/models-checkpoint.py b/featurevis/.ipynb_checkpoints/models-checkpoint.py deleted file mode 100644 index 96362b7..0000000 --- a/featurevis/.ipynb_checkpoints/models-checkpoint.py +++ /dev/null @@ -1,114 +0,0 @@ -import torch - -from featurevis.utils import varargin - - -class Ensemble(): - """ Average the response across a set of models. - - Arguments: - models (list): A list of pytorch models. - readout_key (str): String identifying the scan whose neurons will be outputted by - the model - eye_pos (torch.Tensor): A [1 x 2] tensor with the position of the pupil(x, y). - This shifts the FOV of all cells. Default (None) is position at center of - screen (i.e., it disables the shifter). - behavior (torch.Tensor): A [1 x 3] tensor with the behavior parameters - (pupil_dilation, dpupil_dilation/dt, treadmill). Default is to return results - without modulation. - neuron_idx (int or slice or list): Neuron(s) to return. Default returns all cells. - y_shift, x_shift (float or torch tensor): Overwrite the learnt (per-cell readout) - shift with these values for all cells. Values are clipped to [-1, 1] (see - torch.nn.functional.grid_sample). Default uses the learnt readout shift. - average_batch (boolean): If True, responses are averaged across all images in the - batch (output is a num_neurons tensor). Otherwise, output is a num_images x - num_neurons tensor. - device (torch.Device or str): Where to load the models. - - Note: - We copy the models to avoid overwriting the gradients (and grid if x_shift or - y_shift is set) of the original models. You can access our copy of the models as - my_ensemble.models. - """ - def __init__(self, models, readout_key, eye_pos=None, behavior=None, - neuron_idx=slice(None), y_shift=None, x_shift=None, - average_batch=True, device='cuda'): - import copy - self.models = [] - for m in models: - m_copy = type(m)(core=m.core, readout=m.readout, modulator=m.modulator, nonlinearity=m.nonlinearity, shifter=m.shifter) - m_copy.load_state_dict(m.state_dict()) - self.models.append(m_copy) -# self.models = [copy.deepcopy(m) for m in models] - self.readout_key = readout_key - self.eye_pos = None if eye_pos is None else eye_pos.to(device) - self.behavior = None if behavior is None else behavior.to(device) - self.neuron_idx = neuron_idx - self.y_shift = y_shift - self.x_shift = x_shift - self.average_batch = average_batch - self.device = device - - for m in self.models: - # If needed, change readout shifts to the desired ones - with torch.no_grad(): - if self.y_shift is not None: - m.readout[readout_key].grid[..., 1] = self.y_shift - if self.x_shift is not None: - m.readout[readout_key].grid[..., 0] = self.x_shift - - m.to(device) - m.eval() - - def __call__(self, x): - resps = [m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:, - self.neuron_idx] for m in self.models] - resps = torch.stack(resps) # num_models x batch_size x num_neurons - resp = resps.mean(0).mean(0) if self.average_batch else resps.mean(0) - - return resp - - -class VGG19Core(): - """ A pretrained VGG-19. Output will be intermediate feature representation - (N x C x H x W) at the desired layer. - - Arguments: - layer (int): Index (0-based) of the layer that will be optimized. - use_batchnorm (boolean): Whether to download the version with batchnorm. - device (torch.Device or str): Where to place the model. - """ - def __init__(self, layer, use_batchnorm=True, device='cuda'): - from torchvision import models - - vgg19 = (models.vgg19_bn(pretrained=True) if use_batchnorm else - models.vgg19(pretrained=True)) - if layer < len(vgg19.features): - self.model = vgg19.features[:layer + 1] - else: - raise ValueError('layer out of range (max is', len(vgg19.features)) - self.model.to(device) - self.model.eval() - - @varargin - def __call__(self, x): - return self.model(x) - - -class VGG19(): - """ A pretrained VGG-19. Output will be the average of one channel across spatial - dimensions. - - Arguments: - layer (int): Index (0-based) of the layer that will be optimized. - channel (int)_: Index (0-based) of the channel that will be optimized. - use_batchnorm (boolean): Whether to download the version with batchnorm. - device (torch.Device or str): Where to place the model. - """ - def __init__(self, layer, channel, use_batchnorm=True, device='cuda'): - self.model = VGG19Core(layer, use_batchnorm, device) - self.channel = channel - - def __call__(self, x): - resp = self.model(x)[:, self.channel, :, :].mean() - return resp diff --git a/featurevis/.ipynb_checkpoints/ops-checkpoint.py b/featurevis/.ipynb_checkpoints/ops-checkpoint.py deleted file mode 100644 index 713d1e0..0000000 --- a/featurevis/.ipynb_checkpoints/ops-checkpoint.py +++ /dev/null @@ -1,562 +0,0 @@ -import warnings - -import torch -import torch.nn.functional as F -from torch import nn -from scipy import signal - -from featurevis.utils import varargin - - -################################## REGULARIZERS ########################################## -class DoNothing(nn.Module): - def forward(self, x): - return x - -class Feature_Vector_Ensemble(): - def __init__(self, models, readout_key, eye_pos=None, behavior=None, neuron_idx=slice(None), average_batch=True, device='cuda'): - import copy - - self.models = [copy.deepcopy(m) for m in models] - self.readout_key = readout_key - self.eye_pos = None if eye_pos is None else eye_pos.to(device) - self.behavior = None if behavior is None else behavior.to(device) - self.neuron_idx = neuron_idx - self.average_batch = average_batch - self.device = device - - def __call__(self, x, iteration=None): - vecs = [] - - for m in self.models: - m.to(self.device) - m.eval() - - def feature_vector_forward(x, self=m.readout[self.readout_key], shift=None): - if self.positive: - positive(self.features) - self.grid.data = torch.clamp(self.grid.data, -1, 1) - N, c, w, h = x.size() - m = self.gauss_pyramid.scale_n + 1 - feat = self.features.view(1, m * c, self.outdims) - - if shift is None: - grid = self.grid.expand(N, self.outdims, 1, 2) - else: - grid = self.grid.expand(N, self.outdims, 1, 2) + shift[:, None, None, :] - pools = [F.grid_sample(xx, grid) for xx in self.gauss_pyramid(x)] - y = torch.cat(pools, dim=1).squeeze(-1) - return y - - m.readout[self.readout_key].forward = feature_vector_forward # monkey patching the original readout forward - m.modulator = None # avoids using the modulator on the output of readout (this is part of the forward of the model in base.py) - m.nonlinearity = DoNothing() # to avoid applying the nonlinearity in the forward of the model - - vecs.append(m(x, self.readout_key, eye_pos=self.eye_pos, behavior=self.behavior)[:,:, self.neuron_idx]) - - vecs = torch.cat(vecs, dim=1) # batch_size x (num_models x feature_vec_length) - #vecs = vecs.mean(0).mean(0) if self.average_batch else vecs.mean(0) # copied from original Emsemble - - return vecs - - -class TotalVariation(): - """ Total variation regularization. - - Arguments: - weight (float): Weight of the regularization. - isotropic (bool): Whether to use the isotropic or anisotropic definition of Total - Variation. Default is anisotropic (l1-norm of the gradient). - """ - def __init__(self, weight=1, isotropic=False): - self.weight = weight - self.isotropic = isotropic - - @varargin - def __call__(self, x): - # Using the definitions from Wikipedia. - diffs_y = torch.abs(x[:, :, 1:] - x[:, :, -1:]) - diffs_x = torch.abs(x[:, :, :, 1:] - x[:, :, :, :-1]) - if self.isotropic: - tv = torch.sqrt(diffs_y[:, :, :, :-1] ** 2 + - diffs_x[:, :, :-1, :] ** 2).reshape(len(x), -1).sum(-1) # per image - else: - tv = diffs_y.reshape(len(x), -1).sum(-1) + diffs_x.reshape(len(x), -1).sum(-1) # per image - loss = self.weight * torch.mean(tv) - - return loss - - -class LpNorm(): - """Computes the lp-norm of an input. - - Arguments: - weight (float): Weight of the regularization - p (int): Degree for the l-p norm. - """ - def __init__(self, weight=1, p=6): - self.weight = weight - self.p = p - - @varargin - def __call__(self, x): - lpnorm = (torch.abs(x) ** self.p).reshape(len(x), -1).sum(-1) ** (1 / self.p) - loss = self.weight * torch.mean(lpnorm) - return loss - - -class Similarity(): - """ Compute similarity metrics across all examples in one batch. - - Arguments: - weight (float): Weight of the regularization. - metric (str): What metric to use when computing pairwise similarities. One of: - correlation: Masked correlation. - cosine: Cosine similarity of the masked input. - neg_euclidean: Negative of euclidean distance between the masked input. - combine_op (function): Function used to agglomerate pairwise similarities. - mask (torch.tensor or None): Mask to use when calculating similarities. Expected - to be in [0, 1] range and be broadcastable with input. - """ - def __init__(self, weight=1, metric='correlation', combine_op=torch.max, mask=None): - self.weight = weight - self.metric = metric - self.combine_op = combine_op - self.mask = mask - - @varargin - def __call__(self, x): - if len(x) < 2: - warnings.warn('Only one image in the batch. Similarity regularization will' - 'return 0') - return 0 - - # Mask x - masked_x = x if self.mask is None else x * self.mask - flat_x = masked_x.view(len(x), -1) - - # Compute similarity matrix - if self.metric == 'correlation': - if self.mask is None: - residuals = flat_x - flat_x.mean(-1, keepdim=True) - numer = torch.mm(residuals, residuals.t()) - ssr = (residuals ** 2).sum(-1) - else: - mask_sum = self.mask.sum() * (flat_x.shape[-1] / len(self.mask.view(-1))) - mean = flat_x.sum(-1) / mask_sum - residuals = x - mean.view(len(x), *[1, ] * (x.dim() - 1)) # N x 1 x 1 x 1 - numer = (residuals[None, :] * residuals[:, None] * self.mask).view( - len(x), len(x), -1).sum(-1) - ssr = ((residuals ** 2) * self.mask).view(len(x), -1).sum(-1) - sim_matrix = numer / (torch.sqrt(torch.ger(ssr, ssr)) + 1e-9) - elif self.metric == 'cosine': - norms = torch.norm(flat_x, dim=-1) - sim_matrix = torch.mm(flat_x, flat_x.t()) / (torch.ger(norms, norms) + 1e-9) - elif self.metric == 'neg_euclidean': - sim_matrix = -torch.norm(flat_x[None, :, :] - flat_x[:, None, :], dim=-1) - else: - raise ValueError('Invalid metric name:{}'.format(self.metric)) - - # Compute overall similarity - triu_idx = torch.triu(torch.ones(len(x), len(x)), diagonal=1) == 1 - similarity = self.combine_op(sim_matrix[triu_idx]) - - loss = self.weight * similarity - - return loss - - -# class PixelCNN(): -# def __init__(self, weight=1): -# self.weight = weight -# -# self.pixel_cnn = ... # load the model -# -# @varargin -# def __call__(self, x): -# # Modify x to make it a valid input to pixel cnn (add channels) -# prior = self.pixel_cnn(x) -# loss = self.weight * prior - - -################################ TRANSFORMS ############################################## -class Jitter(): - """ Jitter the image at random by some certain amount. - - Arguments: - max_jitter(tuple of ints): Maximum amount of jitter in y, x. - """ - def __init__(self, max_jitter): - self.max_jitter = max_jitter if isinstance(max_jitter, tuple) else (max_jitter, - max_jitter) - - @varargin - def __call__(self, x): - # Sample how much to jitter - jitter_y = torch.randint(-self.max_jitter[0], self.max_jitter[0] + 1, (1,), - dtype=torch.int32).item() - jitter_x = torch.randint(-self.max_jitter[1], self.max_jitter[1] + 1, (1,), - dtype=torch.int32).item() - - # Pad and crop the rest - pad_y = (jitter_y, 0) if jitter_y >= 0 else (0, -jitter_y) - pad_x = (jitter_x, 0) if jitter_x >= 0 else (0, -jitter_x) - padded_x = F.pad(x, pad=(*pad_x, *pad_y), mode='reflect') - - # Crop - h, w = x.shape[-2:] - jittered_x = padded_x[..., slice(0, h) if jitter_y > 0 else slice(-jitter_y, None), - slice(0,w) if jitter_x > 0 else slice(-jitter_x, None)] - - return jittered_x - - -class RandomCrop(): - """ Take a random crop of the input image. - - Arguments: - height (int): Height of the crop. - width (int): Width of the crop - """ - def __init__(self, height, width): - self.height = height - self.width = width - - @varargin - def __call__(self, x): - crop_y = torch.randint(0, max(0, x.shape[-2] - self.height) + 1, (1,), - dtype=torch.int32).item() - crop_x = torch.randint(0, max(0, x.shape[-1] - self.width) + 1, (1,), - dtype=torch.int32).item() - cropped_x = x[..., crop_y: crop_y + self.height, crop_x: crop_x + self.width] - - return cropped_x - - -class BatchedCrops(): - """ Create a batch of crops of the original image. - - Arguments: - height (int): Height of the crop - width (int): Width of the crop - step_size (int or tuple): Number of pixels in y, x to step for each crop. - sigma (float or tuple): Sigma in y, x for the gaussian mask applied to each batch. - None to avoid masking - - Note: - Increasing the stride of every convolution to stride * step_size produces the same - effect in a much more memory efficient way but it will be architecture dependent - and may not play nice with the rest of transforms. - """ - def __init__(self, height, width, step_size, sigma=None): - self.height = height - self.width = width - self.step_size = step_size if isinstance(step_size, tuple) else (step_size,) * 2 - self.sigma = sigma if sigma is None or isinstance(sigma, tuple) else (sigma,) * 2 - - # If needed, create gaussian mask - if sigma is not None: - y_gaussian = signal.gaussian(height, std=self.sigma[0]) - x_gaussian = signal.gaussian(width, std=self.sigma[1]) - self.mask = y_gaussian[:, None] * x_gaussian - - @varargin - def __call__(self, x): - if len(x) > 1: - raise ValueError('x can only have one example.') - if x.shape[-2] < self.height or x.shape[-1] < self.width: - raise ValueError('x should be larger than the expected crop') - - # Take crops - crops = [] - for i in range(0, x.shape[-2] - self.height + 1, self.step_size[0]): - for j in range(0, x.shape[-1] - self.width + 1, self.step_size[1]): - crops.append(x[..., i: i + self.height, j: j + self.width]) - crops = torch.cat(crops, dim=0) - - # Multiply by a gaussian mask if needed - if self.sigma is not None: - mask = torch.as_tensor(self.mask, device=crops.device, dtype=crops.dtype) - crops = crops * mask - - return crops - - -class ChangeRange(): - """ This changes the range of x as follows: - new_x = sigmoid(x) * (desired_max - desired_min) + desired_min - - Arguments: - x_min (float or tensor): Minimum desired value for the output. If a tensor it - needs to be broadcastable with x. - x_max (float or tensor): Minimum desired value for the output. If a tensor it - needs to be broadcastable with x. - """ - def __init__(self, x_min, x_max): - self.x_min = x_min - self.x_max = x_max - - @varargin - def __call__(self, x): - new_x = torch.sigmoid(x) * (self.x_max - self.x_min) + self.x_min - return new_x - - -class Resize(): - """ Resize images. - - Arguments: - scale_factor (float): Factor to rescale the images: - new_h, new_w = round(scale_factor * (old_h, old_w)). - resize_method (str): 'nearest' or 'bilinear' interpolation. - - Note: - This changes the dimensions of the image. - """ - def __init__(self, scale_factor, resize_method='bilinear'): - self.scale_factor = scale_factor - self.resample_method = resize_method - - @varargin - def __call__(self, x): - new_height = int(round(x.shape[-2] * self.scale_factor)) - new_width = int(round(x.shape[-1] * self.scale_factor)) - return F.upsample(x, (new_height, new_width), mode=self.resize_method) - - -class GrayscaleToRGB(): - """ Transforms a single channel image into three channels (by copying the channel).""" - @varargin - def __call__(self, x): - if x.dim() != 4 or x.shape[1] != 1: - raise ValueError('Image is not grayscale!') - - return x.expand(-1, 3, -1, -1) - - -class Identity(): - """ Transform that returns the input as is.""" - @varargin - def __call__(self, x): - return x - - -############################## GRADIENT OPERATIONS ####################################### -class ChangeNorm(): - """ Change the norm of the input. - - Arguments: - norm (float or tensor): Desired norm. If tensor, it should be the same length as - x. - """ - def __init__(self, norm): - self.norm = norm - - @varargin - def __call__(self, x): - x_norm = torch.norm(x.view(len(x), -1), dim=-1) - renorm = x * (self.norm / x_norm).view(len(x), *[1,] * (x.dim() - 1)) - return renorm - - -class ClipRange(): - """Clip the value of x to some specified range. - - Arguments: - x_min (float): Lower valid value. - x_max (float): Higher valid value. - """ - def __init__(self, x_min, x_max): - self.x_min = x_min - self.x_max = x_max - - @varargin - def __call__(self, x): - return torch.clamp(x, self.x_min, self.x_max) - - -class FourierSmoothing(): - """ Smooth the input in the frequency domain. - - Image is transformed to fourier domain, power densities at i, j are multiplied by - (1 - ||f||)**freq_exp where ||f|| = sqrt(f_i**2 + f_j**2) and the image is brought - back to the spatial domain: - new_x = ifft((1 - freqs) ** freq_exp * fft(x)) - - Arguments: - freq_exp (float): Exponent for the frequency mask. Higher numbers produce more - smoothing. - - Note: - Consider just using Gaussian blurring. Faster and easier to explain. - """ - def __init__(self, freq_exp): - self.freq_exp = freq_exp - - @varargin - def __call__(self, x): - # Create mask of frequencies (following np.fft.rfftfreq and np.fft.fftfreq docs) - h, w = x.shape[-2:] - freq_y = torch.cat([torch.arange((h - 1) // 2 + 1, dtype=torch.float32), - -torch.arange(h // 2, 0, -1, dtype=torch.float32)]) / h # fftfreq - freq_x = torch.arange(w // 2 + 1, dtype=torch.float32) / w # rfftfreq - yx_freq = torch.sqrt(freq_y[:, None] ** 2 + freq_x ** 2) - - # Create smoothing mask - norm_freq = yx_freq * torch.sqrt(torch.tensor(2.0)) # 0-1 - mask = (1 - norm_freq) ** self.freq_exp - - # Smooth - freq = torch.rfft(x, signal_ndim=2) # same output as np.fft.rfft2 - mask = torch.as_tensor(mask, device=freq.device, dtype=freq.dtype).unsqueeze(-1) - smooth = torch.irfft(freq * mask, signal_ndim=2, signal_sizes=x.shape[-2:]) - return smooth - - -class DivideByMeanOfAbsolute(): - """ Divides x by the mean of absolute x. """ - @varargin - def __call__(self, x): - return x / torch.abs(x).view(len(x), -1).mean(-1) - - -class MultiplyBy(): - """Multiply x by some constant. - - Arguments: - const: Number x will be multiplied by - decay_factor: Compute const every iteration as `const + decay_factor * (iteration - - 1)`. Ignored if None. - """ - def __init__(self, const, decay_factor=None): - self.const = const - self.decay_factor = decay_factor - - @varargin - def __call__(self, x, iteration=None): - if self.decay_factor is None: - const = self.const - else: - const = self.const + self.decay_factor * (iteration - 1) - - return const * x - - -########################### POST UPDATE OPERATIONS ####################################### -class GaussianBlur(): - """ Blur an image with a Gaussian window. - - Arguments: - sigma (float or tuple): Standard deviation in y, x used for the gaussian blurring. - decay_factor (float): Compute sigma every iteration as `sigma + decay_factor * - (iteration - 1)`. Ignored if None. - truncate (float): Gaussian window is truncated after this number of standard - deviations to each side. Size of kernel = 8 * sigma + 1 - pad_mode (string): Mode for the padding used for the blurring. Valid values are: - 'constant', 'reflect' and 'replicate' - """ - def __init__(self, sigma, decay_factor=None, truncate=4, pad_mode='reflect'): - self.sigma = sigma if isinstance(sigma, tuple) else (sigma,) * 2 - self.decay_factor = decay_factor - self.truncate = truncate - self.pad_mode = pad_mode - - @varargin - def __call__(self, x, iteration=None): - num_channels = x.shape[1] - - # Update sigma if needed - if self.decay_factor is None: - sigma = self.sigma - else: - sigma = tuple(s + self.decay_factor * (iteration - 1) for s in self.sigma) - - # Define 1-d kernels to use for blurring - y_halfsize = max(int(round(sigma[0] * self.truncate)), 1) - y_gaussian = signal.gaussian(2 * y_halfsize + 1, std=sigma[0]) - x_halfsize = max(int(round(sigma[1] * self.truncate)), 1) - x_gaussian = signal.gaussian(2 * x_halfsize + 1, std=sigma[1]) - y_gaussian = torch.as_tensor(y_gaussian, device=x.device, dtype=x.dtype) - x_gaussian = torch.as_tensor(x_gaussian, device=x.device, dtype=x.dtype) - - # Blur - padded_x = F.pad(x, pad=(x_halfsize, x_halfsize, y_halfsize, y_halfsize), - mode=self.pad_mode) - blurred_x = F.conv2d(padded_x, y_gaussian.repeat(num_channels, 1, 1)[..., None], - groups=num_channels) - blurred_x = F.conv2d(blurred_x, x_gaussian.repeat(num_channels, 1, 1, 1), - groups=num_channels) - final_x = blurred_x / (y_gaussian.sum() * x_gaussian.sum()) # normalize - - return final_x - - -class ChangeStd(): - """ Change the standard deviation of input. - - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. - """ - def __init__(self, std): - self.std = std - - @varargin - def __call__(self, x): - x_std = torch.std(x.view(len(x), -1), dim=-1) - fixed_std = x * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) - return fixed_std - -class ChangeStats(): - """ Change the standard deviation of input. - - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. - """ - def __init__(self, std, mean): - self.std = std - self.mean = mean - - @varargin - def __call__(self, x): - x_std = torch.std(x.view(len(x), -1), dim=-1) - x_mean = torch.mean(x.view(len(x), -1), dim=-1) - fixed_im = (x - x_mean) * (self.std / (x_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean - return fixed_im - -class ChangeMaskStd(): - """ Change the standard deviation of input. - - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. - """ - def __init__(self, std, mask): - self.std = std - self.mask = mask - - @varargin - def __call__(self, x): - mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() - mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) - fixed_std = x * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) - return fixed_std - -class ChangeMaskStats(): - """ Change the standard deviation of input. - - Arguments: - std (float or tensor): Desired std. If tensor, it should be the same length as x. - """ - def __init__(self, std, mean, mask, fix_bg=False): - self.std = std - self.mask = mask - self.mean = mean - self.fix_bg = fix_bg - - @varargin - def __call__(self, x): - mask_mean = torch.sum(x * self.mask, (-1, -2), keepdim=True) / self.mask.sum() - mask_std = torch.sqrt(torch.sum(((x - mask_mean) ** 2) * self.mask, (-1, -2), keepdim=True) / self.mask.sum()) - fixed_im = (x - mask_mean) * (self.std / (mask_std + 1e-9)).view(len(x), *[1, ] * (x.dim() - 1)) + self.mean - if self.fix_bg: - fixed_im = fixed_im * self.mask + self.mean * (1 - self.mask) - return fixed_im diff --git a/featurevis/.ipynb_checkpoints/utils-checkpoint.py b/featurevis/.ipynb_checkpoints/utils-checkpoint.py deleted file mode 100644 index 262f679..0000000 --- a/featurevis/.ipynb_checkpoints/utils-checkpoint.py +++ /dev/null @@ -1,88 +0,0 @@ -import torch - - -def varargin(f): - """ Decorator to make a function able to ignore named parameters not declared in its - definition. - - Arguments: - f (function): Original function. - - Usage: - @varargin - def my_f(x): - # ... - is equivalent to - def my_f(x, **kwargs): - #... - Using the decorator is recommended because it makes it explicit that my_f won't - use arguments received in the kwargs dictionary. - """ - import inspect - import functools - - # Find the name of parameters expected by f - f_params = inspect.signature(f).parameters.values() - param_names = [p.name for p in f_params] # name of parameters expected by f - receives_kwargs = any([p.kind == inspect.Parameter.VAR_KEYWORD for p in - f_params]) # f receives a dictionary of **kwargs - - @functools.wraps(f) - def wrapper(*args, **kwargs): - if not receives_kwargs: - # Ignore named parameters not expected by f - kwargs = {k: kwargs[k] for k in kwargs.keys() if k in param_names} - return f(*args, **kwargs) - - return wrapper - - -class Compose(): - """ Chain a set of operations into a single function. - - Each function must receive one positional argument and any number of keyword - arguments. Each function is called with the output of the previous one (as its - positional argument) and all keyword arguments of the original call. - - Arguments: - operations (list): List of functions. - """ - - def __init__(self, operations): - self.operations = operations - - def __call__(self, x, **kwargs): - if len(self.operations) == 0: - out = None - else: - out = self.operations[0](x, **kwargs) - for op in self.operations[1:]: - out = op(out, **kwargs) - - return out - - def __getitem__(self, item): - return self.operations[item] - - -class Combine(): - """ Applies different operations to an input and combines its output. - - Arguments: - operations (list): List of operations - combine_op (function): Function used to combine the results of all the operations. - """ - - def __init__(self, operations, combine_op=torch.sum): - self.operations = operations - self.combine_op = combine_op - - def __call__(self, *args, **kwargs): - if len(self.operations) == 0: - return - else: - results = [op(*args, **kwargs) for op in self.operations] - return self.combine_op(torch.stack(results, dim=0)) - - def __getitem__(self, item): - return self.operations[item] \ No newline at end of file diff --git a/featurevis/__pycache__/__init__.cpython-36.pyc b/featurevis/__pycache__/__init__.cpython-36.pyc deleted file mode 100644 index f7b804d205002bc2f47915c53e11f78e930a940c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 153 zcmXr!<>k6PJ3U^Ofq~&M5W@izkmUfx#XLYFg&~D8harR^g(;Xplldi3gh7+>7NeG* zCSw$TT54iRX;ErfX0cv!eo^X5h9YL5Jec^Ure9o?tdCHE%#4rE%*!l^kJl@xyv1RY Ro1apelWNBZ)LINO9{`PXC7}QS diff --git a/featurevis/__pycache__/__init__.cpython-38.pyc b/featurevis/__pycache__/__init__.cpython-38.pyc deleted file mode 100644 index 81e9f46f6c85f95202226231f075f7e21196fd87..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 184 zcmWIL<>g`kf~8`Q610KzV-N=!FabFZKwK;UBvKes7;_kM8KW2(8B&;n88n$+0!0}# z8E^5Y7bT`-rskEzCl)6IDL+l7DE_q6#FEmY)UwQCz2y9&)FO~sD;bKIffShdrKVq8 ml&p_XhRlqQ&&wB_;6=SEG?7IkB^rWeL{GR$#AX$+3a~6rzXKb>gk&9n7-<%e(nZFh82)Ba6c_%v|;068S38Wq z^+O%M4Obr-hlU>acqp&56c)+=Z*6mxK;QHZ-TDE_1Cq|>OIJ*-RkI3!5@dt2sdjl+g3Oc z_P3ni=Co&{*Y~2_>tB9p@cy^y^LJl#ew@>^dmICMbsCP(CN9$bOSpm$4Na5!Pz&{; zagr15Fvs1eeqn=HCg1wi6MR~EDcSm5A?pybF$><()q#lyj5O0DU0vZ z-LR%)FwkR)A4uJ+NJHv!m79NR%vw^Dt#f_0CL6=LTpKpdwR0U3m&H%znk@73Htu<4 zTWf141@Y5YH3|Ekl<(?dN9JTJ;nJ2X7~M`sdwE`+wdGn>lkH7yxT5BdWim1Hg|NwM z%2s)j2|cfpoL)`l={x2r^==imRl1z(yndn$Tj$VE{6V-jY-62C%KC6!@h&7X{XIr( zoNIr!gJ*?QM+yJpr9U>F)85c{=^NT>+V5y`Rn|5%UOh4H8lo8M4I7YdB+oy~wpWbx zfgbvB6DtbK%+|v#zB1g#=r!4v>*skTMQrPL(OZpqig#rb_Q*VesBXXe2Kfp}cLeFw zYGCfKU_BbidSDIjyC$*a4e?%L`IP>G_2*hb+9srJ@YQXsY9_0Rd4DvQ&NF0lwjnoU zL$365*e@;X!?LEauUS)PF~9ZoH+hh0Zb68IwaLVv6q zw*yCDKcw+dSz*C$&hkF;{4lXmc=kd1M=o1k>B!>h%*jZ7TUisYCqdjh{F_27vmlxD8*eyI|=B+SLWHIR%EE&nv;?MtZ#>;e z6s4ix#C!-HNsyo&q2`;<1fPJ(yq>Tv>|nUenGHkq{1LoDCF3)JS+Y$r-vep~rFOV} zJ&kXOD+sDePozA=JjY`k{8To^27%@siZmnZ1k>T&gh(j}y7S~2gtVE?d~rgH34tt* zTn0Ksx=S>`49ct%dew>j_zptQXo7u62OMlgb(~Rg{Mlz158oQwB9GUb$Z$oJr@()w zb8|Yz`3|d~!bY4mASW1HLxQ+Q0rMJBUc0AbB)w*pGxJ9^Sbt!LT^CuvjT$4{=~{GH zRJ&TxfIHh?PLGw`;f$gOOpcvCJsAA?hoAa!^G%EC5xO>zP_U#D*WzeOR(-n9@)RZwri7Z;c$#`H#d3qQXNb+t}MD~X_ zMR^!(6q!d>kGzEoyn1R;&N>RvxNc;k)5Eq1qCDM2c}lWT$@A4rQ4V@V1(gD#BAvaF zls6;2AL-MmoNZ&0Z}BW1RY(##&UgD!bzu)jmH9$P=fhRFUb4HpaaYt> zPQ_7Wo+B{9Jex&j#fgp@kXOb2sGJ4Y$fRMsI}IY;iRzjB)D;yJd1R*4QDNFu+Jj?v z`d6CxO<3-~9)Btjy{G!|EB>hyEZ$2J%Z=#|_S`Wr^xXzNC<0=lM=&ovZ1(>L(kL~ljEiary+6|Y=d-$3tGgGN^L zroN@Oayy3jJZ2j_t3Ln!#a@dh$LBFz8O-n#xPmk;ff)@Y28UuZ{ftT2dEYZv4U1R#!VHNPhN(Mg|Z@xd< z1bvNbfFJ&W?uK>sif*FE6#pm^3p9fV7)N7Eh4f(EMt}B6EZPWY!U}^whb^yQ_;{9-Uc!k&1inNB0 zD7#jbT@CS17;!ZLV5;dV1MC2xmjEzY0>Es_Re&WX?35EMUU_%{tuVn8|0#C?z^GNl zY8t~w0l<(qJQ_0I7(OO9<+j|Fk0t<2lV%s+LvJ(YiTe$BMdr68>+SC;0EVO^07m&E z=01W)HWH5{K;?d38T(%jD;@h^N`Juz0l*|$LfREbyT)4?07J5xnD<}j(gA?km@&!Z zI>Ac)JRq30TMwA1MG?_LC74f;sD+6^9bHh&Q#m*)A~|t?1b|e8$NoJ^UH>1+SJX(N ztm!;12zwP24aEvIO=?!Dp=c@AsJW15t0T*s;N>Q;Z7$kGuujbeHH6@bEo!#WM0t8; zR*9K=Q6V_C#>mgT3Ad18Z;KF#bux-_+z+Gtsbims9U8ey%@t}Mq2?+zk5a>^q2MhZ zN7H#s{0hDf3w=89h+n1qQgZw`ti(o3!%|10xQgcAfQ`CH#ny1l3)%hta5YJHev($WsnqMb^97**XbXSHH1mOAJVOgDA z$SQ}8Gs`_80pmyFvo!K^)KH3zn;SH|2FN7zC!$LO?xH7n2aT5hSy>br(Ac6J8E4X5 z4R>iCt>_KpPUJ_Ug|?!b$d)x^(S5zB^5zDzDm`x-_sO*ROET?OA(8U>dsWgYF2+MhMKI$3&>5ia-vjYMqynk~bjb22#@|(DkC+%%siJ zc%-=(fYNUyv|Fee6y;V*gXF6trEenTZY|*cG&7; z+`o<_LbyLt3=sMh_y4ZK{gH|wc{{=VscJ$p{R>8o&?|gtcF_7 zq9j#`-Yt#1_x1-%wFkBCnEfZJ_7JZ;yyXE_KbNh3N`Juvkopo!!(t6stiDitc#u6o z`-jrwd$4|T=tO#4!7*@0HetVpN{=n;_YgK8q(Z^)`9&#EkSs4gtWP|wPuLIZ69m~l ztWOXGm*NmfQT5XLghJ023KS`lK0oBKm;~tgiy=EB4FBS@|I;dlf)yPB91%667}Q*t zPvLi{c37-ui_iiLsid1j%P}U{zoFpC7$MAxrKmH+)vJtr0Xj-?-d8_qA%tS@!#c>r zI>^V=LC8($L!0uFGEcf!RXJg~9F=*iy7^@&rNox{rLCkW;6%MsemqojE3O0lJXlQv z)BJ)}N#+=hy6fzI3{W!%UM_)bE}}Gq&8QN{CjwleoNId!gix0lZZVVEQ(rtFoN`!I z6^l5P#;{6;s3;KSFpn%3L8uP;|djf z#uY#?&0GtdTO}%kG?xn(xfY(aP!tj0fFzx2jD#tGj&QiBfEp00D~2~dT%Q+U4(#-w zEQ5Gqsq!HRl!;9I<54iSa8MwI3*eH1nH0igK8OEhnz;7!R4xn%dNWZ;iPbI=9`yTK Mk*Y1tNfGV;0*00?LjV8( diff --git a/featurevis/__pycache__/core.cpython-38.pyc b/featurevis/__pycache__/core.cpython-38.pyc deleted file mode 100644 index a45b3e5b431607af60ad6e76075d57778d86557e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4408 zcmbVQ&2JmW6`xsth@_|wOR{Y15Da>VMO$X#6a@-5NgKp=>Hu|GJ6|9WFe~nmT4}k< z%nT)3US8_ejr9SN#odl|25CHEPdckKJ$Zq!bN|-^az~UFn*kk{|l|&Zr}? z8ih&W;XAi`pZ}R&U;fnpy1>|T4~m^SsZU?P%?Rh)c@iZT5_R5|7t`Y1vyks;a-y)ue9scd$}XU&K7D z#ZJuQb+7U}XM7=M@r5URyb-TVR^pAx>KQxZKwGf--^7LZ!c=lIUWLSFCJ`3B>UcBW zSZ49&B{o^Jd!+kTo^d72x>vKYDAK-Id6lq)^|(mism++Tmkpm>pp`T3Eg!MT#uXVDsc8L(--sjNRK4ZV%0m@S5M~tj{OTTqqXCJX2v0t$V>|++M$IIKy zs~$Pf`giIZ{3Oo^&p+bLu$=k>KltPlG6wI*TjsL2GPwfnjd(NOIx9Y*c+_k>o?^9@ z+Eh>DHN+#&G-3Vh=@i>OG;F+|IqGFZe03UeWa)oL9Xe(j_e}m=>}Ng#>ngCWcxzXX zw;X8&HvT%p7CQ0T_+or9UWr$`1$4x^`&E@O@e6n4_x)2Ty1S!>IQCu9Q?BRB&v2Y8sdgfvNsG|<)6CLM2okr_6GycHBcS3ADinp z$Knk!h_q=B?eZ?Ij>UDMjU2Q!fw`8WXag7BZW63UBL(x8>J9tArf*s6gs&@hyTcF& zqp)#HJdkd1NEiffRl?7#cE?S!m`K^6)HRy1j@a7qT%E?qCr3KnsH-;6iYv&@%M= zuqS+zn`c{11&ve|3y2{#me-|b1!lc7{Dyx0?mzA;k4%AU|2H?SAd zbY@@|bN79S&q=~;KifGZCUt`am;>b#023L6?ikf!9o-ZAet=qlwCMT)E;NkH1Ip^J zy_nMbQFvo9l})6%BTo&e1Q8<1r1lm1 zA>&6Ig}J!-i+vPEW*Q@N;A>rjUWO zgJhNvuv{Be+@B%+kh(0Z{1=em_n=-tdCmijng0{@qSed;ai>2pXuV)J2^oDfgp~;4w>5ASf>ulOFe7*x53bKK$*LtjjON~YU5^O>L{tckNrR$Q<9*L zu=~w+LQNoKVMj?99gLDWkqAU5>Z2;`Fg{V(C2xvZ57-XM;&AO+#&6&ikgD|)BM+SC zhr)wBJB`sG@Vr4x(|3=s9iBc<?g`4Nq;TnNA{gM9Bmo*TXD>9GLC}9$*I>)*(I2 zq;-4>3hEEhhjhR}E863Xi1nvQuqz%YG?57w;n3dg%p z;XAn6aVmu(r@t+y#%qPkSYO4v&exq{Vbw|szKuJT0`BvduvWouvf?oOeOoSW@h#kY z$$=(ptnm1$1Id^8f$< diff --git a/featurevis/__pycache__/exceptions.cpython-36.pyc b/featurevis/__pycache__/exceptions.cpython-36.pyc deleted file mode 100644 index 2002b86441f35ed3d2ac5f8142ad0b4d49751a8a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 381 zcmYjN!AiqG5S>kejm3hXAFxMrXnXJ~QV{K}7r{e7h9x_#3u#h!6VaXo{TV;UYp(u< zCufs3b>Iz;H;>26T#iP=@ptj~4gf!lz9MEbhCAmr2Mt<$G6+7xROsLyk}%^*UxL|; z;ZC^`um{pWi!|)K&DkBPsdo63~Mb}nyJl|7ABo=e)Ra#>nQ)|S@E6%}Mv zMOy0GnqnoFU5b1$u2#9(DxWi1BvBJ17HUn1%@A>2>N@xQ1o4@TyU74iml@(0*dt!E zZNC>&XS3-pm~;QreknKEyjg#vhx5;gMI>5fkp#_ge^VYpnxsGH>Sbn91#6&}S6GkMiz?-p@exBOx*&xKm0~rkUn%1Z1yq&UJLdvRKjN zUvOd*f;*;!jC3rIG|%Hs?@z8#){VuvaaT_Y*R`q2%~V{dHEN+7Ys#fqbS~o2xJDLcBZJRqmL)y~DCG(Pd>>#{>81$v5x@fpx04=#t`xvK zvj?IP2k33zr8h)#)vLUMulk)KMM<$2$VG2TVUC9LbLPzX`Oe|B zjg9u#Uw`t)&YO(=hb=ud^lzc*4?qMHR>b=BZ%5Y1?%Ni-$3#sy&zW#$cE5(Vx@h37 zfj0+lP0_+z3vYE{ea76iZ@`D`xK`de@RhIj!Z@Ij`O`$_7MlJAh-7_Bu)Zyx7FTcB;!=SZ(eDrnCIOn)T#SEzs;#b8^_Z$QNe!2fELrE zq%V?5>OGND-qoqXrq5Cp#(O*zU>y#o)F+vA;K%&gegdgtIZ+UgKMSLX?@A5^<4KxI z!FQ*XD8!xi8Ih_{IhEcx(Y$NK={=CKPUz6v{PU~)kpKKKPt6c`r~76Yd zH=c~csC&50r*5xeONTw!4>i~O;ULv!;Yar$(jFf&1~P)y_+2^hCsE3~J4q~Ej^!0| zKgFUrl?q!{xavSj8S`$~lf7*ord)*DhtY~N%yCjJNwO>V{ev)3C*APct2eB+jNxh{ z2_f`~2wih!PlSOl{w|PpI9Kj&&;-0u*n!v>AM8)J&xce$+QZkH3HkuU7 z7b-1`?1kbGmyh8@it8v0U~Of*3P#&8e$dtK;+VzZ#j)_+O8?cRrk>H;Ha{#nygP^z zSOA<0FD-lkC)`I+JX2v>gatxHL6YuRs!L?jx%aviXYvEXyYe5n>wzClV6Oq#FNEO_ zi&0-m9z@}I4DW@qKEHHzn_qp5SdemsYvHeP+#5{dfXv`Wy*(8QPy3^BB$u>4(WP^g z;+7#+$hFX~U&On&>!*mz?rxG`eT+N*cEBH~iQFcO85DpHA!NB;RG5JKha(_{=3z_@ zzannQwTMjebf3qQkvEUrQo%ib9~;%PP~*67uPvD$uJC=8$>K&r9*}>Op?$Y_BeyZI z@(2gPj0uOSq3Ss@%)x9YN#z2^9>FNdc)GNVcKQcND0ou(#2lFRlrKVpLEiOa!O18* z98|uQsOkcx-;p|ir|uk45)}g9{b&x3{13^56WaMfAc4NgL>1DM2vmZszlf#L)B|c6 zFz*$!g;sVR;+ zD_bAd&>XZnS_7>q?62y_ovbr#;cackW|oD$Lu=U1I@Eu9<`K(ma9hu6f<0-eeZk^Z zRvUJ*HE?9!M&_9DKbdi-8sE(7n0+H_fNo_?&{J6p^mMic`sQIwr$9OZ>COz_nz6s! zGAD0=+nV|}X15@bli6>x;aO3?K~kNfxxX^?lKM-tjT`I{^7E(cckK5J<3=`cTOXdA zG2G#wG>a_R+)+>xbL-G!qGaAIgDGDtAuCaNCr;uhjDZbdI?bCUB=^2C8||JV-MjcV z@8^lpc$zl~Gv!V?1)3oLGSwhLiCwjbtbycjkh6L^^-~G_4br^5)NlAejacOCOGz}h z(=C zfg*2Gr-+~?V(JW$w}_l2a*oJ(B5xB}2g$8bzcKPi3;$q>W8~$#m$eEm52TMofvDBX z-O`<*vXq8j@`!GX{%#hMDOU-yxi%{ z`2;rcz~i9R%BJt4^9B3D8lavM_Vd=4Y{>4y%a85U8rm5ut798uHT7O*4;@jPSp|iU zm+!~5tOnn4b^0u40wjq#ZFT6wk}so@XME`W?@EI`N}&rs;Vi2{2qY<%0Sl zm@AhEUnQgyMP{eKGsm|sIF^IsH!qs;0OQp|3vZ$6AA_t^+-t%S_2*XKk*MiK^ErG4 zHFgU|Yv*eZ@7=q4{SKhR--R>q+kA|=MEQUV!7+E~>UHEmQ@&Q!EQ%eeMpA?bdR_(v zaxpe)WEoR}nT*oiLBVSo$hR+RE%AyH;sxwPwR zDXPR&tV#F5xhl2CX*ddxq*$a~)Eh++5hrT2Tu30}Qg)}zDUxS#m3NUpH5JsR#5RQj z?OZVYj(L0>`N;NFA}{toP!!Ao5qik9)W3tK4?rlUBQ~;*9iY9fE@lpb4qr)MS#cZv zTG2nQXIAQD^Is%vqJECOKu{tdHR7$bDH`)tGyBiTZNmn#A`rpkr3Ph3 zYc-EpCVn2cR=>S)1d}0-E)?3Pau|7D`7yr5x+DJ()q>mZuNx=^HbQZRN56Hjw|Dir zw;Shm)5~j-jPq9MFgmXr_o z5kv9xDVp8_VOGc9LeOqnXU+f7>B`|>g;^WxsTpHXxIWn^kEqv>$YZzOB366o{ zd~-BK@nbZDT+CiQtN@7}*DhSZZK|Kr?w=8%WT7q*A?XzfaWW)a#_Y#vnw+QA0w8o0 zjlCWYh~ewupa27Wb{9}kH=6PP{#{{!9J@@*z#-n^JV{!2tp+pJ@j882vssETsEs^&a4I$uuP?kv|YGx z%{Yqj(BBmbV)H9?Ctq4Qfz!!q*Xwx{&tD!{Mh}_eJ5_$JL zlmzhR1*-2M>U!!Gbl{*SwrA`Z^~+pR3bsO?pP=W~7P(t>X^K~*ioG$0O4+(gvVA-9 z8Yf5IiFx=}V7*K1P0+0&=p033Kq@LW`df?Yus2D=NEbm&dMI>Gi9PB?f1xkwcc{5|lDOE1zElIAAu00k@Laxg^oNy| z4#V^5#ee-}MT65%1B2UW_SYbaDW0-E{fm?jMPG1spQ(oOo-ySeiGBm4rfOl- z!pOs@t$d7pjGBr+V8PPY;KSAfUirI`iOg1##WZvJX<~32&0Yi1tj`te3&r~lC6v&f z5=WfQ95mfo9Gu-L{gx7RLgjy)Sv}lLb#&}8ChzQO6K!c(Y-?$>9p!i{quAuu%1ByW z$b2A&xzefabvhEy9kVqa>a4IIxgkx}?`1blY!Q4U??~#<#?gL}n|OQ1fELqZbfofe z5kA)YvTF;2O%Do_WLq*(V4V#1sZTQ5ILhSH?Hp2NdTbz`e43=G+|&{bM&qK;N^b7Y zL?Q09&xtgf)%!Xe*_;l&BmZ<=?#W*~l7*WB?_%5S$Lgd=@{Ddl{6^zZ zl6Lpj&_3lHkcnXKfFE`zB|+Z>{3zf>fvToz$Lqzd5$2+ z!0@*Nxnah7Z59C7ZV(0adNm6NuuO&s7AupCY(3*lelX!$J0%%8lG%6|PMx;)FKFpA zY&1_3i{oBjJ7K=J!1qlib7d*LORAZ8^}TvT8gmi#5C5z)>7)07^bK z^(m8}n&3uc<#0bl06JXiO{FBQu5VOcJXTTc1MQ~I5<0*xM(}I@2BH9hDf>Hn&ITMX z*m&lb{2n{vB@1~eKt@_&|5lToITl54B+am8xCn=BGX5pLy-M#GLGu@j#xG?*V(s2=tZKBeKFvQHkEQiVt6MTptsLSp55^SFMS!4s?Xbg01c8?nG&${i<`5 z&^OM9qgy|sLrGIDCfLCTQ{?Z3VUi_981`Pi%O z)t-Q9dd3IT3HCQs#W`F<>}ohMf&lqP6uWcCm3W@X5Jz4E)mj@d5_3(%p zwGHK9vkX%CQ^CKFk<%s*wkO4iQu-9ujT z7qI>gL!*D8*q0uT=3lsD2I3N{eIgKnnCoXf@ZPGiHaNc&<|6(ozE^9Elx0>xdT5q} zXmRoCGWT9BH~~zbzTF9&9|uimr>g0aX4SMs6hC$rs=Of~r{_*Jm%+c^q~gI=9{trq zT*CCsZ1quBNE{N5@nr}@#*$*eSoOM~O{UI}mBO&PhhANLS z-E=9!yiX_okO+m#DdO}&#%`fmaz3AX7d%d3AzpRP8+sR`Ej%=N8_oUT2-@D|ipK7624Eq#9f{`DJobA-(%fB+@N2sz0_NrplN@2*_Gfh6Ecmsur) zM5oPAt0XG4oWwVh5jI-DtV_QRPP^+UR_>zx2JK-WQ9e*@qO?s6xTn#+HfL99?zPLR zl=CvBkz%i1*^I1K!4%2sHN`eK&&sS(kqnaqt>$@WY;~PQv)l|%XHujbN^g`pRQ@!Z zB_1RYOU0BcuUw|2opXlYFp-VY2z5r53g@2IB$(yDopeSxr~l#rb-+Nw2ObtL|Z zG_un=Mp8N9;7xs(5?n%P*9jruE|4|=@twIdd`)TM;Bu{TDu<91O_ZS)?+&9qR1iU@ zf6j#-pdQL|Jo^6b*4FhK;bvAfU9W1SI;;GN)7Yx%G*fjxkJ7RJ*qGdy^Ek&)>Iqsk zOf=n@)yjeyYt(hX+@%fk5OUE&vGpr7OIVHY73X>9l@P1^0(#5*;N6+q&$7z`)T~e@{t9ThSoXa?8uG$kFAdgaZHkAF$bt06O>v$vfb*Rmv ztdA*Iv@yQQ4_2M)ygjDK5ee$<(vCHdX-p}m09aJ9*1ehzyi4p@oUlU_HFJ4g+&QVJ zsKN!Dtd!Hu4~V=bAw}b#(IyghPf7TCEVj;$#WRyM)k(i6_H-|V;ZnylGzaMVF8=!G s=hbg-TqLPAF04rtwdQH@DVd%0q}s~ASyvIa2zKiz7t4*+Ypa+415!+W%K!iX diff --git a/featurevis/__pycache__/ops.cpython-36.pyc b/featurevis/__pycache__/ops.cpython-36.pyc deleted file mode 100644 index be4d20f31ef5e7c081a3fa1992921d775e900a6d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21895 zcmdsfTZ|l6dS2c7Iy227IpTe#T3Sm^)6|H%ATbE8JWEp4YO|VkBt~nrcik>_RrhqW zZ#q@O=^6KI0*w}{T`!$=e2pCh0oHcxAPB>@b$j06iL57tufq zaPocssj9wAQxe4mVx-ABbV zzS%Wu`fk=tDO(-8szi0UQ!0wa} z?b;G*3Vsna#Y3yMj8e%jqf|y|1*Ii_8Kq^EDk!b^6_hF{9Yg7uzlzc-N~BNxP&$RuNt90eXHYtW(i%!<{c|XtL+L4$&ifZox`5Itls@A> zjndO7okr;y-$ltq=?qGr^)I4y5v8*z{h0qOO3$Kn4yDiemr%Nd(s`6F`|BvJqjUkK zs(%HgD=2*ir62dNqI4Cdr%`&&-#}>trDsrj-oJ*@HI!W6e9Nf5@Bxoyt7^tpzmGH@ zwp)F#i(K)6r##ha_Zw`H{w!oRafNG00)wYjvwYLH-ZN^pZ=**iF5Mn%4WjLKztv!K z{&>ex8@F(UJpC~TH@AM@s9LcT2Hj?Cj#M5GB>C{O&xfkh-u>ulEN2PM7)Rdi|XpudAP^ays;6 z5~{?y9Fpa9h@vUwnH^z+O*Ys-GPNUSVEg7FcE-1xIp6Vf@0m5nFZy}EfLu;?zZ9Ro zqt{q}J7`1$Re!Y~2EBXTVC!z|GHV=&yqNn0D&VzY-z zhZTCOxyv7xZ*<#X)EM-JuMn{0JoCo>%a7Qdje5P^Z%6g|#*OZv;dR4TkV!kJmK3KJ z=W*0QH;k85;Q51{sD3}#i>+u77lOT@J{*K`@m{d)J!lV9T-d^Hbv;8}e=@1s?{5ET!3F9Bf6V`t2s02ZAkT+6=w5TN55-?Vg! zx|ODV7C>hj?<{}Sh$@|906M_>L+ijElN#i=vWYKYuG~U_oBx2!*z6c;HR2smV;T{N zKJrcn>tg#=E|AXQf(*xW; zkiM42?59i;b?AKC=wCfr%l7G_bgt=~HBP6vg#{6}I>3lS!LWl8X1YAaxLjyw#Rpy; zl*eT(x488I(c}Z-$PB`eO31?hIOF6*K7N=LWmg! z^?vL;Xa~Es0+1AggmFF?4ZXe}+YK*@3*kFEL9icGmlVNXurSVr+wEo)n_IEjh|S&D z+*T*>u;y?kac(#m0P#&tVStL9h(^Uzi`UEsA&B(f ziwQMI(I?whoZ^IHJdKesuV;B%)imWa@<3d8VG_fInic7-0JnXTsp?JAJ z=y%)wz*FsLFV1_zVbJ%dMiIKS&VI?8s(DSpxQlVA9f8P2?EyDGXoRwT>aVkH#)UKD zr58xrCiLDg9cvl;Q?yR4Rt(BAe-sJR9f03s4kQDL995BX<0QMFuIe+a_(>*{ z;Uy4Hca@U*P zffrS;yIooK!Q!hAzN`??*+gtU0v1I(03CrD!x5+&~nCvfY;b7WecL= z{^{An$(Vj7RT4llR=AF%(*$)w&B3TJsc%|jQe)&&DlZJo*7auq4+qwQH+5_MKKQ|r z_ca@I&En=Aw&YyZGuT0)=Z}>@ z!Xj0PZSP(vX9@EDjsmGxLAdP=gV^o{{n!q7dWy##JH5c`Pm`Zo!EZO4VSO*nj3Agj zh@I{r4Cmp3MB#7X(sGl1-Mj+6x98@i+eQ)vGISN)i%uTR_@&fxo3(9it265l=U zT88h(^o|_GbGG0nlWc^WNHn%mo9O^gI(7s>m8urtKIhxW$&>StxDKERb@FIm7(*Zi z{A;lkIt}UC1nME)3!}WvTAA)0=17p#7num%dL6l{Ghw5(e0Rt_Qv}fY1rlxoTmm}= z!PVTKEO8c0)fRi62UYcDb}Ov$qrvnIw5z2<74rh7teXK-cCpDu*O1I`NT{d*rEaGQ z(cRBOJx!>2cllFjB%my(q0pnCR|y(08d{?nJOlxI?e4cH3aC z+1%SfxZ!>U^BXiL9GzV^AZ-O*Vg1+LH@xtE;7`|0=AavgkjJiLYj~gZzL#>>p6(z) zY`&8I`a!E6>@>PAdEH^7p}u^0D=#oogl>H{Er zbEn^+jDWqllVmAc_!Kd`R;xScQ5Xy!u`LZG{^#!=|C$Vse)W>7`CGk!BB7A%zr*G@|OCoZ!(>Qb)O#O0tl;e}susJtjfB z4>Ln#b}SG%6ZTK&)*x({G!)(Su?YhYNuCV?XNhp2-#T_kJscXmpSy2;&s0B~z4IL` z-G)H1N|E@Xbq0b$1hpDl;dDxe&`2RDIKBzuTK11a=*ahfz;~fwLvZOV`6teDW~_1i zlZTk$c>`k?Xf=R^6bkuy1B$pgEpQ!&iZ9oFUqnT+#}fyc^@kNp_RVf|6`1q^Oxk^A13c6>qu5Z zp>s;eO9jz0uncpICCs7!uJp2uUM%${SCQ@T`KcYgFxlb99O*M0iRZ`@kr7v;Rez;( zoa3_BcTMzo0@q2sw>rf-9lwG%o%_}SZ9i+{(s+rMo`YqSo*FOXv{%L}K$)kvM2g(M z^_6}XWDZoX-GlXvm`viN$-O&)`8h=h$lUF!0CwKKdrb_Dnlt}RAi-UjI|}z`E z^{an+=`WTxj=vJ;8$w(Y^|`h(LpW=8FAVliz21ik-S$%^KqK$EVBwyy z{wK~=Pl=om7h#U>gS&*W!<;4wSFsKyWP-wjmYc0!FE%5QD`?4p#4MHo^(tD#b}LY^ zL#ZMzzwLE*f>)J-g)$F0tq0qN0|vVjJJ{z?6P}xRsalzmNs5{u)JJ#+! zz&ud49Q%y9Y9nW!fatSoJ!@7Vw_k!e#WkOX`JiH6M0y?9v*t}})xKy}tg^K~OCA%; zL1|8i*OHM|LVDillgLOvg?V*3LlNbd9dj+OST`dh*{IlLqi2!K%Sdo>IItnmln+FJ z4IvNkFU0vTwIdi)_8+=BBVey_0AdK(m_O*b_x9WnT-JrDBl3V6UT?6|{|M0@i>h~| z-}Pt*Hb9C25Zgmxw4-)!rTQ(y}zul4`hlKc{@&n^qrY z<1y%N(*oClcLq!v-}3BVD6!cO@T(L41H<^Xd6TQI}Rtvopa2hqgdC#mHmhXo46haxyx?~ z{@#Lx4hVkNyAP2x#cAj`!&I&pfnIaIN9#7*iGfh--(Q?D53;j~F0tG8A>t;A`d6ip znCI9|^6*hu@n7*uxQxWGTwnz+;KJtHYLEx0P6J$hQ$BT8@w!W1_Ks*NxL zuluCvk*SNH06VA_hEXuA)9)mRL{(LI8CdAnPVXKJ?3n1VJ%W!oWt~()`IZ>P0=867;K^K+|cm-rd^7zWsh71+L zAR39y5nje1+uNYo1mod`cy4b8JJ1^_m>2@w_FOz{H|QL2cfCFL-VWL!3jv-wx(Cl6 zm`#Hr8?GPF7loEt$JFF|c&k5%++mj)_9 zxPf-?KfG%qSiu^7BLZ2G7Emd%w>DH__$rXg`v_4uv=PYg(+FyKGi$f3dzxwoAyL|0 zg(zq7-28mP2Ebmx5^(P5PuN2iqVV0X8t?cBQz&*y5Z!V#e29G*f*sEPf1+N(9MIni zu8LoT=toAA(`FTrzr=5{e_`Y{fY@-q?zspd0qy~F6HDiY)`zPjH{2fVbj5xJvnkX% zAS+%Xw8OzI7BHbN0xcBmsB}QOrjV}4sDw{x^^_b-v#Mj-C|zg8ggucd#W~;(h7s_% z!RJ(v#P_SArR0TmZMW09X*SS|Zzd`r-q`@wE~3%UrqE#w!|DT{r`7!cwA98Cz}@Y=8aNG_dP&_ z`X-Y(aHgbth2Tu)B97;^DPTBC4+&npZs7`DBouXNqy@bprvNo0N9ceK(HIM=0f=|B z<)@H9hn@(hlunP5B+M=ZqWK9D-!`%dS{Kayxd}e8xOj*WT#mr4DV9WBWL*PS_Op@O z#1&pbG9xY)7mAAoth^NG-vrF>2i`^El+J585d2+ag9U*UIxMK^F(NVnI{^G0T?W8H zR=|>z$Osx6r_fMC_HKRqDgb=9z6*?0FtzyWGo1o62VI|yc-yTe!47;GonyXrnE$s2 ze(F)W%pe;`D3^(Xm+!T8)Xim@WCArDX!lUEpjlDv2pNGb6DSPPER&DLR-~mJgd`?? zKQ7EKPp_|b43ibNTe6N6%D#i6i&tirI1g<^ho8)#4U)qCu{UK)j$#54hKk=UT;Uxg zkr8Q0fbkN*fHm03U^0fmCaDK^pQ?x77Quy#R<&t@0{6Ec>Yza#n2;Dc2IzUh3Sn`x zvF%`XJXXyDxh%19#Kj#bB@CKVzks@FUoB%i0T!Zk*Gd8#)T`&0Ph`85qJm*DKyzvX zQcN?|x7q!t=40>U?U&P0ie+)wvTiZLkxx$}T;MROSd5SmOMzy&xbm9v_5=j(4&Hq2 z=KfE)cQZlS^}v++Eg%fpSwBb=F#_)Z(g=e9k_RDTkf=Tk_fpj&c~IS$u_tDS{vu`u zLC%0r$GmTc=a7d$NL$=}TU~_q4`;jxhc?75hrXsm&KF^lgdGu$_fNmB{RN?@1_(dW z>-g*kBsg=%c^v4otQEmWM4;zTOf8b6p^MJ*%jr%V);S6$r)M_{fSsP}e0Z9+Gs|2F z7*m}K6QNkFzK7&XDZ&&@$CR2+eUio3sW!pMzP~;>LrRXYC5xLxOC#Fg1VN-7&Ylfs zq7jm_PQvVE-XFJ1Z*vV$=ONPVA5SOognRSL=VnACbX$lP2^srif@h@Z0-5HvmeF)94CN;+Jzb@$I}zw9#8Yo}5$V)|sm=>C zMVCxukrAF-dka@c%eU5DQKo)~a`9rNhT0FI+r_r!p+dS|es z+JSnjH_+crd1dU7tBV3fiF-jC51J}KNPNGs=fblHXJP_C85@mK&abVFP2G9Y_^LY; zFancd^gc|0U@YycZU^=|*!d73+}3u=dwW9B)?a|$IvzL2J6X>{F4@dv(g zn2AF-v6hM{bcW1_>47a2{cl0Whh0{=ogLUVcf?%#8b5%bP554SM=3~I8_;WD1!PpW z@6x7=EC>ZQxhqFYZZac#eH0tPml(+jrM%?t6L&;bnFuVzRhl?bUUGIG{Ei~*5?&#~ z3BvwwWGM6@vOaZ)BFu=vNx0~8ML3afo)d>GY8+ZplP9co{Blz3EEz3W56OKHe#Cd- zG@X5KY~xuD&%{d0@wC-dLRxZ686^z|ZJup#!GcJggTY9?HHHfbM5TZ@&?258APMo{ zdGNgwN~LjeT*60AC4@5-9@_Z4X$d{C-3o$TifdSdta4eeQmldcD<4<^pTQoaj8IH< z*iU@dqko$){VqY%htH!9k8BTzF)_7S>NnAXy{O|w@`*){CmlNq*r5InvXc?x(oR45h6YYyHo&JeVo??nI&tUb1$f}c zlKZGu*c;WEg|-AvEm^S##tv)osi;8zJamzR|6M}YDP#=zdY?v|#|87Ey#~u*1$O7B z&HY6X_r&D+H!$2mMxJ3C1Yc*}V)D!bnU*#e=v1d}w;uq1Z|=Q;h|I4vzi=<4Qzh8H z6IV!Rp5Asu8Bbh| zMIC*dIU5mk{Dx*odpGy?|5KXR+pfcDKw=RP`w@XO@P&m@=J6Y4-m0UVj+E998s1)A zTb>xjE0Ov1r-6WL-&*$F6pg??r=QT0J9&?0->lUPyLirhq55;M$+mz`;LYu(#LlLE zE*o3JAMY8FUqxZs&y{Kn7QV6Ltm5VAp;IyKckq__T_y`i{~x4BC1TpibXRZgO~`&a z6&@R}Te#%=W)M?Eups921l5KEyT8UeYZ(heWdTM{dgDQW0moLNELeInoYu55pgxZZ zC6k?-CyB@pI8Q>gVU?k^ufa(^GgnP8C?`INN8z{8|367bD#{lgmZ@0V;Lz!hyReDt zC;*o<(2AZ~mY{jC9|VWd@VgW*rwsol_`SD@b9I>mw@>6EiDmZOv>D(N@nXA=)(L1p zUg&}b8u<7e9-#Oj`ED)sM@yu4D(a-}!ifNqf#@_OP0X$-66k>!A%T7}j|5q_#H$HH zK$?6s60m8c5TVX+f=pbS+Z%qsmNxQTuSwwve{BHfqs*&Mn!wGNnM1ZQ;`9(7JjJsO z#HJ!d0L1%#plBTXy!#VC;dD_iWPLCkig8$C6NcnQ9}J7>&N4uXX0w^?o``vGOF*jV zZIHRulsBKNzAV@bN_P3GdpU{zx-2pwN)X7oBbQ|=Tk4kphpLC9kwd~C@5EWb(`(4k zMVrO=LF~z#-4ZoZmv|Yv#^E4`Gh1USMH)B)+qj8$T6~6rxG~~D^`S@@nCwCt0Yf*m z#_r!^?)RC@Av5L8KS@!{fCM06@K2@3N_;pVo46`OSI(L58`e zgArCmx-8+zamb$e&IwAw{082qhulUGw~df=J}o1pK6#4g3}cjMsLyv!A~?Uubd3S- zOXDRR?6M}ov>nNhoQ2@>5-#yx;cqvbIe?^#Ss3qwxN9Q*wt-LjLDC5tBIkn2$}yvO z9IwV^h@8-G5hdlwOL*{M=|(H)Lw!-N{5j8@<2lCu`rK)2;yv}LdHRwL0T);_6+fQ9 zFw??wA61GT0XWR#ds;+5q`FHtTfU?6JMRN6BCJ&hij1r{OmhhHQ%ss%D*gL&?Vk-}2_!>epw!LnX^1V7hn;POX zvWjnT;E1&)p%4rfs}=AmFEj@2|C`xeZmfKy_#e5Y&!PmLXp<|Rvo8Rlcp;R-UX^dx z8PK^*H|clD2QY75TFU z-juRWu{lugX;Uw$=^~$E1ZSQoPBUKg)Y^+c9dVX_LSyga8+a2?7Gz<55s~~~DZ&^g zOji_D}Q3G@SmaI|DKLeWMr_d zSog#bnnaAe6?swkR~tr&fBf-I5E8I?q+%gNSH1{IwFx=p*YV=~>5;ML(c_WG3E7mR za7(_E!L35!(Qu0=_@*~gkMZFaL~BAcREsepEJW>)P~rtpotyPspe^FS_@NoNS@Gjw zdkV_)nnBD#x$K01dh#V8sh|4iNNR9y&=LSMoB(`#p?ib2-9)cpIQ;c2oFm<}Cx-cd zfw}OcbvTEPhG*Rq!~BXSN^ihO3c~dNAJpH)Ce1)SD;7ch=^3a$HM1=r1NZNuOAYsc zOAAt@M9(~wza4?UgG9*<@e=r^T}(t{+EOiizNgzR(ONRy78Xll1hEA!cA@cku85>r1@7E`}iEvux>HZT*8wXJJv_VKpmTgkH6~d z;?9g#i4D>Gf--nwh~h`n4BA=n>9m}>00F5aK0s`b>i1fyt~g;N(&XQw$^2=PrL1SC zEt(=Ckj~6);K!iYKSd`$aufq1J`S3pExt1bvKgI{`aKCo2C}mjZUrE7Vk^^3=|_i* zWzDia9vOwhD;`05I>N?&z%%*RO#UU41-Q7u)1h{5;QN&gurJ1vFFK(VBh5RXK2GZ2 zV3>>3NLkJ+)>S{Nei}DfZ0)4}iv<1tM*4RS@Odu*H!e?AxU9&9jW+)J7$u>2HThFu z`16t*_*SADD$3Py9!4Gfg-H1eTk>b7m`6!TU_U$K;op z{0bAghQ$G)zR%omGofxI;-?}%R-`Yoo~ezNEvLd47jMAagsHp&@f9`@Bt`s1GXCYQ uWoy|v;Z&ZloUfdyY*n7AoT|J~SwmW`6f4IotCdTYLgjSjTICo@$Nw*Nh(K@v diff --git a/featurevis/__pycache__/ops.cpython-38.pyc b/featurevis/__pycache__/ops.cpython-38.pyc deleted file mode 100644 index ea3db9bc0d40732d4948281045c19c1153532588..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21101 zcmc(HYm6P&ec!z9b9XP7b&>`M3N&q=P0@bohay0M4qzZfKP39n4{d=0 zK~wej`=6P)kG)Howtx;f=bm%s%z6Ib|Nrcd&&`z$Tz~%Emp$vIVf;51MlTzMtGL5& zn1r(w_C+_X{982r&VsxtjtJ0 z*P3n5t<0ImYlffq3-23#;jXn(L8<7MP%5Ex2&J+=gVGF2^C->wb12QBbQqR zC>=p*-am}eVU&)dbi_Z3(ovKaP+IVxK=xTgntsHlPDcW>6CvO zrPC;#Kv%2Xj<&a2QS*+cnqCytI$hP4>LO}9wbty^`Qqr6 z9rZcX2F8l%8#rPU$6N9pKli@5;siN;On1$dykErd<+yUI8+omFWSC~R<5d7BuGG1D zY*e}`Sleo$N#Bc5Tq>7cT%S{GTkW6|g;%7=s_me;wjQ~QjaJu-s#n}E>Tuvki|?%mctN>Q*WC&Od3o5Vt6Z-$Ec!vC*=cfKF2<3WXY*n2 z+0vHWSAvFzO~rs?JuJ2^zrg+F`<&;R^86+iR$Y>gKERF`H|pHp^kUw^eI0i=k7QsD zjG8g9kYd|!8V}9osukz;e#E70wpBZJ!l2bqCA_4Fx(^LCi=V%K=98hSf3gvH(UuDC zG{ezsw-+w;cH?5L#+BA;$M8bvATi9m**`vhf=g+uI%k+(d1N@I%yS6!#;`CjMak{==u}J19Q)s^5*FK&Xo7{80-a4r5Af(Y*^~A(3d?(#~+=G z9uuv7`=~J>g&NLNp6MF)#}>yiv-?hz8<=-Z-+Ex(&m%SWoX*98wZDE~@2@*<>^YcI z0W&HNoCoHDv6ma3z+|p_(&P82SUyp5XHIzfdp}wc0xS)b?-RlLh z-3mIf9d5PdoMWdQc%5oq&EW0W+*v93%|;`v?WUQX*oyANPOBS+0t`BtV{4pw-D|aK zwNogCXOI~774rtp{hWFB!@QX{tPdU2`Y>-_H0P};u%O=tG|DP&JS?!wj@J%qwYXfX zwY&aSi}~4F?Y%9pl{_ibYJRs~tEmbGR5>Q6nGjS*5>8POwAd^xA}N|qq3l?u)Yefk zb`fu`;tn5+MCHHGTLyaefAM;^-P?+SP_VSs%aGRVxXlipd_06HqaHnXu?Z@01$1Lg z1%cZDFEn}3(7{c3JQAU}T{sqEWo-7Uwt$Bw49}u&a+|rumv9de|B&97 z=?G8qz*`XhDl!^vAAnG8SVw_&kt4`r0$Fmt`2c9cC#Q|0#vXHdv@Z;RL_h?4U;`2C zWpxPs$aTzEBRKB8>a}&lj|dVeHwSjtu!ov zv)Lc6a2$-)Su|0^hLK(bHU%P|!GkL96e9Bik*uxb9=o_jS8<2j+A*eS`F7xJ)<(c1q^qA z&Tg>dwRhIiDWaT?`{7Jk^WRs)Vm@uLm8sE=bkvthqg} zskWQox7pmALAd0;h52s_USmPi9v+&8^&Gw?_2hI7!3!)7PAg0122u=m}R z;kI=L2@dm>^y&m_wP35>YWkp{SKQ@b4P)NneB7+s^_yYjb?Vr~AleSFBqHhbKC#$U z%%Ro=Za20%b&3txn;S`%(uPl|!&_Txb=!f0=ykxhWK@C!xr@ROmZG2&f=J;1GENm8 zb8Av5M(?)Qsza2DxZmU3{OV3Gs7HaHb<91$R8|85$xmFm=w5!;RbFQ;fbin8dR28j zzwTl2tF6G@Zbs`V8RV;ir}50lNiEk&$kU5?0IVhuM5R#~W&r+Nvj*UZHSpe>h9*{y zCRTY3SaEr{n_zKRX*D-O!${)Qc_xcYhMYrCl+^6=xCKQi#_(VN=n$KxQ#HOuZY)&o zKBgaG+F<$SrlC$n=6#E7AF2uH6=)cyzFAa@1G7`);x=s1GD`#k{g(5<0&O#Z!$k2?47S+1MH1F;eQ2X+J2OHugBD;)bJF&@lbt8U(WYa}S_Aoj~hfwSEqw z5`+?mqK=4W7DOv4QDkeNv>;4Jh#$$4{}&n1^1yrevp5F z-SbPw4a~0eb+bc(DCd`DZ~k#q*qDbP=J+%Bti7`A2KGqrhP+=Mlpk2>+nxU)@6O7* zf04YKtRq*~GU9x6*st6_ z!f|QLJxabceCdqJQWf(oJh`W?i#LxAW^vkcgE_E>`DH}~ zp@03YP74GN^sm|WfWyFPk||C2-67mhXh}fpR!ap?3Oep3MNLFA;ZGoU>!BGJHiMw& zH`{{kfBB35`P^U4EFFG1&ew(3qJfQvD|2IXbj5CmLI2q6ojV=~YswQS`Ca*Yd(b?K ze$!inD%h$X7mgkmw>{MX#R_AGIYH>yxzh}`m0&sfyvPHw)o#aTBqBhZ6Iob^V6em% zN0G$#TA*TwQb1gO$7^i`uPW75aUQ}|+lyicta2-Muuq{T9u$wNl@S@Ds407G2k(H8 z)^=7(5WAZ`gx4_6b)b@}6&r%|iZrZI2OebSGO z%ByV3r<2mp`-T_{XgZ+8llSug=R%x+qZvhk>fdv9M!;CZGz1JVD8JiwS9jeI{L`%m zD)Ip8Uc0;1d4zn9rPVg1-^FMPf)N=!WbaT|=uWe})lRzL1Kp4qw0qIr(Xz&vvP-tc zr3sfHYa{MP=3Prwzzg!AyJmx`I;d#M+U&U8gmj_>3Fvp6L|h(D3xYbeH}wjWDZK3G zQLiOe0E6{m|B&9C>0FF@Kc!rm-~U1;GB!jm_sx@_LZBc}#-Z3+$HB?)3{>}?bKiLY z?v=F!^-o$NH>D-jYI8HEeEv49PSH09)(p4?IEpP#{yu+`C$>DvMY#>`4tU!ySrmHj z*?TB&Q0#^JebV^5)?NX83$`Qa-BEuQv0oVdI^_s;Goa>oE$QD;e<9C`$uo?=XEZPD zl?EjW&&!&gk)KyhAz+|aIX~Kk1`SoZ(Skhm(2DJz=R>~e`oRbP7drS7a76H-Kv)Bi z$eF}B@=eQBA{te#Ue@EL)N~r_594f_=nv%`?!@M}Q(xXAV|jK8Fr} zhMgu#b*@OInzeP@V;3R)D(?MCbF!eeNZ$RZ+-X_G#6nmkk z^itVegmTTZ4%ScB6T6>Qmp?yd^Mu$mvAVIH$i4yzb!TLa%oC>t zU#MPEnoG@XT2vjyGVe&;LQ;_+0P@f>P7E6bFH65XO zNSRprn$I^HlW;>Y2_kCPtfqkxEWl8 zdX))P{iW)RR`b8WnyXBRQA&1DHt$UqxtFosZ}#H6*XsoxKhEC)A+2x1N+3j2>;60h zAXr|0!Gq;cVynK38%&(V-a+{Fdl(|*$s6Fa&WHIVb-;VUTfs}mPAD}NXrgj3lHEdo z-)7GVlI6=eAQ@{P1IY?gkqpk5YB8R@M!i1puM_^fcLBrhbp;bIaZMyYVwvniif&!i zgl*qz{h%0^X_4Op!a-Sd!zk$0!e&1Z+@uC8ED-#6d8@q&Q#>ZxYwiRsFZ`9w!*LpL!PM90Han@YvR&#Vjkf{(~AnW zXzF*mlwqNLLO|7yiREq-49yjjy*{w9GoDg5Snloo?jzTFiihX$_xB1LWOE00tZ|q~ILtZ68CW-S~$|;rGbMMPS%2&ud!KD zKNsaU3hWa)B4rR8dSOoLXg`GEEU5!oO0_)dtb@FaQzXT%=CpPsf&i73F!F^4fyWQY z^fk;~aTReX15pwAy)zcXQr8`P_viJW38Ld4+?sC*Z1Y0XLORxs810nYIrV)Nx%GfoM zaM&|mLc1K>f#6#a`1fdgXvwB95{Ts|jk`7&!L2N=USGt|L>@W-n%h7ur}s!SNsxW#T=MY zPTN>;wq@-&>7Utg>p<)-_1|@m#yencVgOxI!gk1P`qdpbT<>nR#I^;KDilRvEZ!u@ z2Z?n|h>U>Cl6nDeK|aj;@Rvc+plVh$t}*V#QV5kE7SkT*qFo1z@CWf%mf} zy};{ml-8wIyIf=gNqBZ#F9hjswYu9Q-rr8JUE6Vg6n4$EHi+`#PSw5OF8WZ;75F-I zDfb1?x}?nfpsFrMrIbiz#|K?EViKZ9x7Vhh~r+S~oS_{m`$=1n_ zxAQP@Fm>^k>M@xBUD{UvhFyy2O>^wR2uMt)bDRoqnTm@H1WV90?PVfup(T^QaIeDh znrholqQNDQqNl@&rCu# z%Lw8TLb+G#7v*OgIH+K6@fXKB1uk}5J{$38yPAYI@MUz4`PN|9U+?;v{z z+0j+59Kw{vx0b9Xg{V6?#dvOPp_7nB1UQmG77^gk+p;m!VV`J1CyKy6`9x$ynx}); z66P16Z{L-GiKL#=&#)dI*bM|MP?4iG3d*2;kA7AJ9Ar!pc9A#GGt6!_wmr_tv1-P~ z1*x}?#KkQr7j!48ZMGe8xW;7x3(?0{O3aHoFu8D|)G;ocVvAv&Fi(swJ;5hTWeZOa z=1&oxB6KW6tFm}qS$i;A(Kt71cMKdKB9Ry>AV5+;j4Q7xZ&!}^R`>1KuJ!+xdn*%r zT@TErvj(&vo9YCK+C&iT0#oR;PacGbEuygB+f5aLfx&C;5|63 zV}PemrXwJ%!-TNGx*zB;i?379fwR27I6Ov5d9WOdlS2y{+UNusqZ#f$9?VG}4>x%L z6Na!m4bxvj)img?av|iIhSfiu&SAJg>Ziuvlg*xE-ItM^pV$S~9lQ(Y@N^WU;VGIH zeMbX9DL#4&Knkh1<$s~M8MK<~-LCKbM~nyID|sLkAHt zTVtMgk>3F&*Kvoxj3iOa>1~J2FhX=1*a4i0$mMX;jz`7;~oJF9cWQYSqO5TUT0kZ%-J%Ny;CyhNL zvOq^|q*%S=oygjNI>`_ueJ6oPFdA?yZLAblNe?UH>o_3X1%3m;w7taL*y^suR<8*n z`z+rfrH#$D*5$@&D&iTuRsw9-iSj%r0}9+R`0e_aGK3srY9<#fz0~UBebIP z`8tz-$mFX?;6M%9Jw?~SBpsx9^TS-1sHPHdaSqO^BL3y!n=HaBnKz5M{+UOubnJl1 zK)B}u$Q@*GoQ#P8gM47#Hy;=}9s|cp`G(OJ{LQJC#A*bPq%m9~Bkax+L3Sg*NzkW- zNS7cTEg-lPHVYH>iIMgakp@YLC$9nFdE{XFp^;c0eQB!`zPA+wID))_i4A(b?3(Nq zw=M}+iOoI_A&gdvg7ki^zfwxjx27g{k&O2Z?jnK5fG;<1E?7@7SnYs)(>xf_bIZ35 zmYwdRuNP971G6ob7r<^=TjwyNmyNfK%m$f3d3{zqMTdpn$t)w436UiSPLMcrj zLG<}tv~8_xU!=KnXwM;GrtQ>4WGuOh7iN@~3dliTT(a!zTrBB`CX+)?kEwnHwW(*8 z`N_i~$iK^NWj_Yui-!A<;qDkj6Ph#e?+p~h--@`R$WEgr5hiVkEsT~=z~^arYxPrD zNNtJXaUd{?=F1o!*u!-EB%t*WdK9yjHge{)cSUASSyS7tNTSAs`23E9{}YP2$&-sD zMBe5iwe)_WJW={-D{ckcWpr@@hVoajl zozVgzBH)@08ve!7bg;5KY7(Nv(%puwP)D;!w?olm)Nq5ApU3wJ)0)CjdnM!?g~*_ybMF-V9*#0suwPBAq=S(+-xSu;^|JcdY~~WYpUrr03Xq%FuOyANQ2nfMDHklXGW82k|B&yWuixhkW)E9TuhgovIEN1lNdpE@DDPKF#9Jbfp9u@&fqnM zp$T^WA7o$$fFzrR#2|>2p{Ef%{SZ+g&-(T$3CTeXYy$VvC#;1VC#iL2j5UZ!WFYY8 z^Ib^4%uv z`itlv;ii!D>BcFcR2mcqCCK_E1gpYzgD_R-1k!E}p^U`^j4`@OzYO;d0z9F#&Lrk3 z2^A3W>s4%tmdMH9=r-YX6_JE9Fz~{eT|=BsTQyLL)A<$rtjs14C?JOj?-SbxNt7`cF?^1TZ(<)}I>hMfww4&adOaudpi$N{K~_b^A7z zeETZykdQFCsbjXBl6*@Eg%+WawC0rK@|&8M>|WdLe>ctRP1VtmppN)b;Sq6=h(-vb zEaqY-ix=3>q(~(FpziG^J_CMUAzw!^q5-s5M>inG0N*gsHUwkZZT*B^x8Zwq(Pgd1 zDE$lWINBN3>0}cLZ+MRrp$H*qu9t`Z~@N^8=#S$+uzyN66<`#(p;e@LXK6!9G!xIJLf19OT;5gek;@z;u0%GK zuZ27}Z3aSvxb5wOH7X=s;xOO=Y7Y1ECI34s}{8O8pg z=QE{ddf;i)Oh1{VW?8o+kVDD_iT+?}#-@?NH(-p+%S7ghy`h0OZRERNg90ox7x;Cu z067wOZpPRgvW<~Q0|{rNh`fYvJ`imO{dY4^^j!U@`x(&UbWxYHJ{XqF;Ae5m0^=ae zzsX{{vkX*5wf=N1t;}{ApTF}P57COD_o$J;IIjAW;B%b$)^k|6_8NnE% z7wm_mm`e+3HPzBEg4gY@(hEpdaRxbr(|1lq_D>r>jZk{=T^3pUigx`v5xz-}@(7qi zKo;r?+9eDtI78(STIC~R7qT`(xugw3?ybFi_7)t;6K@rgx6o7a7TU;L#i)#sECz|q z;-152YY5(#Ivm1CT`{U`9D+rI)_#oMa4^C=^a2}tL1p7Gr2jlVf5N8$klgU6BjB>O zwe&Af%Y$P26wmo7L82Mpt)uw(t;lqNACS!qW^lOB7RVs$*um@~#U|K%3U}xt85r-L z*n=+sGcmpjs;n99I|d?^!FCBE(h2@bh8#D1{?^i^*bE<9N~p64`f~D=^WxG=Ye5Iv zq3F2j@;eyq-*a3d z9)y;eGCy2mEq8A0;(lJm{WwPOk~aR{jQqbIvw^2ndxV97DkmQ!XJmMq(=7E@_V%gM}yP zJwX?!KD32jnpkqGBvM@-c{w8<>R;i({~iItoCs&E{aAo7iL$&Ic~Pi-pS=>4(~EhY z#&z5WNA}^oZ=-?e%&DlFRg5f3keM8CmOH|e6=QS~)hAP!4g@65)RAQxUqfa(5HMaz zK3;)$ZdB=~heV!1O9F!sF?*QmKLI0pmE|Mec+7v26VS=Qf07%54%(s}zk~)W$ZG() zg-sxMDAFi31f;wsu(w$|1SGL82s9;MsEcI(uhD1)&J`LvU_g{u1K6pifYdxUP-|vq zKm(Vvn8S1vKN76|0AuCTUO?OQ_gt*4;~u*R1XpqIk2!qQ-*KALi2Wvvxu9?YS~rA` z?UU9p3w^R=Eu*dtk;xEPkUAS|4Q7jI7F(-psn~TJWo;wNW6x@7MA0z$u)sgBBV_Hz zFyULOid1{1hk#kufXO|V%@dQR-ryme3Pk@2oBT17bi=j%fM)sxR3%I5_ixyAV&h2y z&vN5gZ{QQ;CG!%*-cx3O-}Wa^TeUQ#9PFO{BlL8feI}eaCm%|&_A#LMQC}k-8ikCM zG~PHEbVV6-UeRzmWrI^l#fQBIa_)bJ4xdj?izHUWN7h!KQ*9hl}nXFC@=g!uga+j diff --git a/featurevis/__pycache__/utils.cpython-36.pyc b/featurevis/__pycache__/utils.cpython-36.pyc deleted file mode 100644 index 81387c2ae912ffed83aec019f34a7735f857be8d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3602 zcmbtX-HzKt6rLG7i8pPRrId<7fl>L}6bML2y+Bp9)fTt_EfobSR;ny-JlXZevC|o+ z+g)X^wy4Vml@PDM4X?m!aOW!|u6PBm_|A;&B>YGSEX~-NpL5QfbH49P-aB`$+x_W> zd*d!+zp{nL!}kW7c^6&GVxF>X7K_+>#J2fIEcWBpBNn$##J0e%cHF_Q4t{wtzr%XL zZ`j4Q2Ap1a{Hl>uvx6??u}IlB+`joSKjr)4l%4Q>Z{I&*$Iuh|kJwDy!q_*WXg%gb z9=9+SxG{`+Grr%ZJ&)OA@z@)B){5YSAA2*8Y>0k_dU;C?avc@9mPIbd(MZWi4yW0m zNb*cZJE@}aWH-yTl36rXv7AI2??P!Kv%HY88l;iNc#_GaFkMMctcFRJkc@uUj@;C{ z)3M45^S)bvHAA^xE9$*3Kh?=@l0|8wyxRDMiFVa|6A9mV01Gr$H=<}1D&_bv9Iij? zEib3ZS7g86ZHza>uF*N9Cvc#c~V5%+wACa9jgBIG#^B% zxq***VUzx}m>}>B?WFD2#PiO?Q?`%f9|>owHL2&7{wT@fa^-fNi{+UwZ+;ej{J~du zKmF`hPiPXSTj+4IPLi348WiqKZJOzzdjYMobAV6#)XsVtzs&3CPCav(05lW?#YX|G zVJFPOj-B!uJ7rG@(B87Yo5Q>W5efPGA|2+GkJ{QlWix&W?R)F{xuYwqOFlvr+Ag@| z8H=`%Vq@m^!`&2h>+UOLYUS>?|LX1o9Ze=mFZjRNNkJc}Lj!d_Ww|~FQSdDv>Q#J| zPgMzL!U_f4uF&McvQr7B6B-&}!WYl+qf7s2La(FG(9RW$`aDlfxnjU9Hm}O=oL0&< zkU3SR^rGyrY>^_<^EKtJewHKz!_cla`T~v7;p=(QV6E4bOwQDxHi^Pw*3hx110Hy5 ze3hT&UGaQJU&dII1hjx;ZlIZUbPAjvvu&gR_}g*3?-+i&<+y#j9S2B*m9n!52;@dZ zl-zQ2F9It@(x^h_LzyEG5s@O$pMh2}0p0+`);w5o-UrcOuNjl$sVQpg%REyO@-4N3 zENgO*Q5K^e%4|B`QJRz?vIn`2Etk~GOkXa`21x;xDLCaIDfTRb<V#h?xz806jC->Hl{h2@W z>iPTE?lN1Zy)DbXiW%RP)$ng(e;b?qDd2= z3s!s)ctO{WE;^6Cqg#Z!^7mV~RuSMi0B)~z+noyV!2;lSl1v@_B5zJm&Xqwy z9uAeJtHnI!=oS^>f|L=q2&~|4+GYVI9p?TM9_A{VTSFx}%qL4XtPks39c~pd*;B2v zz|_i2)578u+2XL;uvG;$auhxECNFQISvqx4n+X68Jn8a7*!(EFb7Oj*%@qea^7TT{ zsDRjzenK({PmH%6?8r-V*bxlqp(O;pr_js>x+U11Co534Im$MLFCef{(Z=1E?TZ4p z=oxO}vHz_&LHV{ew;a%xE+wRa>WI0B&R$AZZ5>DHf5I0oB=#irt>ZPU#rM;Axq3Oz zNV;}>j#k&}S2tZ2;Cv2!3uU^wCV{)WI2i-*S4gDgEOKAj!mWLuti$Z8VDx;sjq@T=Mw;-~;^znPSg9KRiM4E-9oT#*c^ws^Birz>4l+ zR$ry=P3qpFj{aqpo|%sS4esB@;#+7A_ibOS`awt2D4ax+Y`M2YU`H1WZLBSW>yCkL PP{!E{4%p+>)ysbXs=!Ii diff --git a/featurevis/__pycache__/utils.cpython-38.pyc b/featurevis/__pycache__/utils.cpython-38.pyc deleted file mode 100644 index cc6d8e2b9f0f1aeab9f52737edb345c24853c736..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3652 zcmbVP-EJF26rPz~+Z(rp5};5hFti2Y3S53FE~=_Zl>ib&1+|olNY!fN9VZ*FciowF z(?rfyiyAJdgm{5e;-;^_YjC$$NL=v>+`xBce{8oPAy%64?wOf$&YU^lcg8oKd8W3jg)b-M z*ICE=1FP889;cu3aq&xyG@A`{ArD2&zUTIr@ACtGC=S>ozU>^kkJvtJh3Nvf4hf}slKDA4%Llr}O+Ga0I09B9a+L`IouOL{`pkCKRV zblX;PS#OSqD#^@+Vgly$<#J`Hb3uNoqs=G@;@Wt*@P-LC)pQXlU%3MhG-lVTND7m3 zxa;?q?{?;=)8J{@?RM+wk&){5IJy(W@Cf^>2j=y>E6<)C?7))wCylcTZ$zKjY5cQlnuS8yQ4Vj;U(J&AcpgDCr#eTYJX?}>=%(Ebt<}3 zM4D_BzR57MhZX4EVuzYCYd*h3nOoN>zn0K#vI)D@-scm(&3+WO-RtZz>+syA6Migm z(S1MXBTdU}_vh(zM)%J3RgjIfx)Yh%*KrobraRir+ZW@=WZ3fP(ko<$GP=nG+dEku zSodO__JY`4!b>%E4hUqCmOW4FNr`oIsc`gwZS!q05QW3mv5u3wgD45}g|Dit%#VC? z`I>*_lW%W+d2LOTGHk3BC1#|0S+S)SgxW**Dq8Jk4bj zm-9hKuKZU_drD&GPn?Y4Rq(I#wokf@C*ukRj7?^$S?6UqZL;^?f_r=;I`#T^x%kU-JigS_uR%VS7BrD`ub`P_bPALovUMZ{=)EWb zZczZ%8wK^RH$xAJv5>b`fsE9sfHGdLZUrFBKpK_Fv@cT}NI-lEVo1Qa7yzY!eJhGA z>F|@Fw^hsJaBQ-Q7G#jr-T zsxjzhC(5=gxuxT5G`8*%{fvkS(y_6Imjhz7g8l!&iB91~99On$_prQQD6a|tS^f8_ zF%zg|;t-UMFYrTJs!*AN2YYl-)kE*pR?!TV_X#lTqk4n+_|?ZeZ%-8iajsEuU%!cY zQ%IJXwu(DfE#3b?oDaVpR5a^$r=d?ll=Hh5 zpt*yy%SAfF>GgIf-oF1aIY&@ofIw3$@g=?}W;a$$o7>paL1o*P&8{;|#Hl5^$D;7W zjWRWSGMYzxe^X^N;`=L@Tm|&`X+Z1otDRQv`Ih~BKX3c~Fb&7C!uwI*zda6O;zfM5 zd_PQkzOPS1q3%%kE_LMXOlOM#Q5C`1a;C@KHh|yOB<-QiJr2HB&`cNIEbNuL-N5aO zz|R48d;42&mEiYgz`qeCYVS9Bd4#I34C;2juQc62rm07ltpN9^gm6Z{1*_9C3ocpU z?|)%qYNEbel&bx7G}ln-d5f)S;gg=R5A?BI&ybJ704 z%%IPb?I|p+HG=9*vPN>o_lOC~Q=MUg1^pgIH9=9IqmKTH>GSAv$Bc*n1^ORg@)}wN r{nn!EwKPc)8q#E|zvTieopIEo`OsYgp& From c30266e7c1afde6c05ea4b364de054c9fe39dc31 Mon Sep 17 00:00:00 2001 From: Zhiwei Ding Date: Tue, 3 May 2022 15:11:09 -0500 Subject: [PATCH 6/6] delete unnecessary imports --- featurevis/ops.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/featurevis/ops.py b/featurevis/ops.py index ce64ab9..8f49ba9 100644 --- a/featurevis/ops.py +++ b/featurevis/ops.py @@ -1,11 +1,8 @@ import warnings -import numpy as np import torch import torch.nn.functional as F -from torch import nn from scipy import signal -from scipy.stats import multivariate_normal from featurevis.utils import varargin