From ff394b37062281408e9f3b956a13de0b9e682016 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michaela=20Vystr=C4=8Dilov=C3=A1?= Date: Thu, 26 Aug 2021 20:40:11 +0200 Subject: [PATCH 1/9] Fixing bugs in first part of monkey_demo_notebook * replaced all occurences of mlutils with neuralpredictors * method get_module_output not imported from nn.fabrik.nn_helpers.py (it is was removed from there) but instead from nnvision.legacy.nnfabrik.nn_helpers.py * removed some unused imports that caused errors (for example ptrnets) --- .gitignore | 3 ++ nnvision/datasets/monkey_loaders.py | 3 +- nnvision/datasets/mouse_loaders.py | 6 +-- nnvision/datasets/utility.py | 2 +- nnvision/legacy/featurevis/main.py | 2 +- nnvision/legacy/nnfabrik/datasets/mouse.py | 6 +-- nnvision/legacy/nnfabrik/datasets/movies.py | 4 +- .../nnfabrik/datasets/sysident_v1_dataset.py | 2 +- nnvision/legacy/nnfabrik/measures/measures.py | 4 +- .../nnfabrik/models/dynamic_models/cores.py | 2 +- .../models/dynamic_models/readouts.py | 2 +- .../models/gaussian_readout_models.py | 50 +++++++++---------- .../nnfabrik/models/pretrained_models.py | 4 +- nnvision/legacy/nnfabrik/models/v1_models.py | 14 +++--- .../nnfabrik/training/dynamic_trainers.py | 2 +- .../training/dynamic_training/__init__.py | 4 +- nnvision/legacy/nnfabrik/training/trainers.py | 8 +-- nnvision/legacy/nnfabrik/utility/metrics.py | 4 +- .../legacy/nnfabrik/utility/nn_helpers.py | 2 +- nnvision/models/cores.py | 10 ++-- nnvision/models/models.py | 44 ++++++++-------- nnvision/models/ptrmodels.py | 11 ++-- nnvision/models/readouts.py | 14 +++--- nnvision/models/utility.py | 6 +-- nnvision/tables/legacy/from_mei.py | 2 +- nnvision/training/legacy_trainers.py | 6 +-- nnvision/training/trainers.py | 6 +-- nnvision/utility/data_helpers.py | 6 +-- nnvision/utility/measures.py | 4 +- notebooks/Extend_Data_Filetree.ipynb | 2 +- ...ex Mapped Readout on FileTreeDataset.ipynb | 4 +- 31 files changed, 121 insertions(+), 118 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..24bf1631 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +__pycache__ +.ipynb_checkpoints +*.egg-info diff --git a/nnvision/datasets/monkey_loaders.py b/nnvision/datasets/monkey_loaders.py index e13a2024..053d1687 100644 --- a/nnvision/datasets/monkey_loaders.py +++ b/nnvision/datasets/monkey_loaders.py @@ -6,9 +6,8 @@ from collections import namedtuple, Iterable import os from pathlib import Path -from mlutils.data.samplers import RepeatsBatchSampler from .utility import get_validation_split, ImageCache, get_cached_loader, get_fraction_of_training_images -from nnfabrik.utility.nn_helpers import get_module_output, set_random_seed, get_dims_for_loader_dict +from nnfabrik.utility.nn_helpers import set_random_seed, get_dims_for_loader_dict from nnfabrik.utility.dj_helpers import make_hash diff --git a/nnvision/datasets/mouse_loaders.py b/nnvision/datasets/mouse_loaders.py index a197cfd0..1d2baa1a 100644 --- a/nnvision/datasets/mouse_loaders.py +++ b/nnvision/datasets/mouse_loaders.py @@ -3,9 +3,9 @@ import warnings import numpy as np -from mlutils.data.datasets import StaticImageSet, FileTreeDataset -from mlutils.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels, SelectInputChannel -from mlutils.data.samplers import SubsetSequentialSampler +from neuralpredictors.data.datasets import StaticImageSet, FileTreeDataset +from neuralpredictors.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels, SelectInputChannel +from neuralpredictors.data.samplers import SubsetSequentialSampler from nnfabrik.utility.nn_helpers import set_random_seed from .utility import get_oracle_dataloader from torch.utils.data import DataLoader diff --git a/nnvision/datasets/utility.py b/nnvision/datasets/utility.py index 9a14b7e0..83fe6b4b 100644 --- a/nnvision/datasets/utility.py +++ b/nnvision/datasets/utility.py @@ -6,7 +6,7 @@ from skimage.transform import rescale from collections import namedtuple, Iterable import os -from mlutils.data.samplers import RepeatsBatchSampler +from neuralpredictors.data.samplers import RepeatsBatchSampler def get_oracle_dataloader(dat, diff --git a/nnvision/legacy/featurevis/main.py b/nnvision/legacy/featurevis/main.py index 0314df6d..3b475f09 100755 --- a/nnvision/legacy/featurevis/main.py +++ b/nnvision/legacy/featurevis/main.py @@ -7,7 +7,7 @@ from nnfabrik.main import Dataset, schema from nnfabrik.utility.dj_helpers import make_hash from . import integration -from mlutils.data.datasets import StaticImageSet +from neuralpredictors.data.datasets import StaticImageSet class TrainedEnsembleModelTemplate(dj.Manual): diff --git a/nnvision/legacy/nnfabrik/datasets/mouse.py b/nnvision/legacy/nnfabrik/datasets/mouse.py index 410b436a..f8c898f4 100644 --- a/nnvision/legacy/nnfabrik/datasets/mouse.py +++ b/nnvision/legacy/nnfabrik/datasets/mouse.py @@ -6,9 +6,9 @@ from torch.utils.data import DataLoader from torch.utils.data.sampler import SubsetRandomSampler -from mlutils.data.datasets import StaticImageSet -from mlutils.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels -from mlutils.data.samplers import SubsetSequentialSampler +from neuralpredictors.data.datasets import StaticImageSet +from neuralpredictors.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels +from neuralpredictors.data.samplers import SubsetSequentialSampler from ..utility.nn_helpers import set_random_seed diff --git a/nnvision/legacy/nnfabrik/datasets/movies.py b/nnvision/legacy/nnfabrik/datasets/movies.py index e93e2d1d..77455145 100644 --- a/nnvision/legacy/nnfabrik/datasets/movies.py +++ b/nnvision/legacy/nnfabrik/datasets/movies.py @@ -1,7 +1,7 @@ # Mouse Movie Datasets import torch -from mlutils.data.datasets import MovieSet -from mlutils.data.transforms import Subsequence, Subsample, Normalizer, ToTensor +from neuralpredictors.data.datasets import MovieSet +from neuralpredictors.data.transforms import Subsequence, Subsample, Normalizer, ToTensor from torch.utils.data.sampler import SubsetRandomSampler from torch.utils.data import DataLoader import numpy as np diff --git a/nnvision/legacy/nnfabrik/datasets/sysident_v1_dataset.py b/nnvision/legacy/nnfabrik/datasets/sysident_v1_dataset.py index 68e9dfa9..55669649 100644 --- a/nnvision/legacy/nnfabrik/datasets/sysident_v1_dataset.py +++ b/nnvision/legacy/nnfabrik/datasets/sysident_v1_dataset.py @@ -5,7 +5,7 @@ #from retina.retina import warp_image from collections import namedtuple, Iterable import os -from mlutils.data.samplers import RepeatsBatchSampler +from neuralpredictors.data.samplers import RepeatsBatchSampler class ImageCache: diff --git a/nnvision/legacy/nnfabrik/measures/measures.py b/nnvision/legacy/nnfabrik/measures/measures.py index b3e6639b..b21c904b 100644 --- a/nnvision/legacy/nnfabrik/measures/measures.py +++ b/nnvision/legacy/nnfabrik/measures/measures.py @@ -1,8 +1,8 @@ import warnings import numpy as np import torch -from mlutils.measures import corr -from mlutils.training import eval_state, device_state +from neuralpredictors.measures import corr +from neuralpredictors.training import eval_state, device_state import types import contextlib import warnings diff --git a/nnvision/legacy/nnfabrik/models/dynamic_models/cores.py b/nnvision/legacy/nnfabrik/models/dynamic_models/cores.py index 04547ed2..a0b3a1b8 100644 --- a/nnvision/legacy/nnfabrik/models/dynamic_models/cores.py +++ b/nnvision/legacy/nnfabrik/models/dynamic_models/cores.py @@ -7,7 +7,7 @@ from torch.nn import functional as F, Parameter from .misc import DepthSeparableConv2d -from mlutils.regularizers import LaplaceL2, LaplaceL23d +from neuralpredictors.regularizers import LaplaceL2, LaplaceL23d from . import logger as log diff --git a/nnvision/legacy/nnfabrik/models/dynamic_models/readouts.py b/nnvision/legacy/nnfabrik/models/dynamic_models/readouts.py index a37b967c..0d965f5b 100644 --- a/nnvision/legacy/nnfabrik/models/dynamic_models/readouts.py +++ b/nnvision/legacy/nnfabrik/models/dynamic_models/readouts.py @@ -1,6 +1,6 @@ from pprint import pformat -from mlutils.layers.readouts import SpatialTransformerPooled3d +from neuralpredictors.layers.readouts import SpatialTransformerPooled3d from torch.nn import ModuleDict from . import logger as log diff --git a/nnvision/legacy/nnfabrik/models/gaussian_readout_models.py b/nnvision/legacy/nnfabrik/models/gaussian_readout_models.py index 20a3b625..40955a83 100644 --- a/nnvision/legacy/nnfabrik/models/gaussian_readout_models.py +++ b/nnvision/legacy/nnfabrik/models/gaussian_readout_models.py @@ -6,12 +6,12 @@ from torch.nn import Parameter from torch.nn import functional as F from torch.nn import ModuleDict -from mlutils.constraints import positive -from mlutils.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore +from neuralpredictors.constraints import positive +from neuralpredictors.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore from ..utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict -from mlutils import regularizers -from mlutils.layers.readouts import PointPooled2d -from mlutils.layers.legacy import Gaussian2d +from neuralpredictors import regularizers +from neuralpredictors.layers.readouts import PointPooled2d +from neuralpredictors.layers.legacy import Gaussian2d from .pretrained_models import TransferLearningCore # Squeeze and Excitation Block @@ -69,7 +69,7 @@ def __init__( input_kern: kernel size of the first layer (i.e. the input layer) hidden_kern: kernel size of each hidden layer's kernel layers: number of layers - gamma_input: regularizer factor for the input weights (default: LaplaceL2, see mlutils.regularizers) + gamma_input: regularizer factor for the input weights (default: LaplaceL2, see neuralpredictors.regularizers) skip: Adds a skip connection final_nonlinearity: Boolean, if true, appends an ELU layer after the last BatchNorm (if BN=True) bias: Adds a bias layer. Note: bias and batch_norm can not both be true @@ -81,7 +81,7 @@ def __init__( the kernel size (recommended). Setting Padding to 0 is not recommended and leads to artefacts, zero is the default however to recreate backwards compatibility. normalize_laplace_regularizer: Boolean, if set to True, will use the LaplaceL2norm function from - mlutils.regularizers, which returns the regularizer as |laplace(filters)| / |filters| + neuralpredictors.regularizers, which returns the regularizer as |laplace(filters)| / |filters| input_regularizer: String that must match one of the regularizers in ..regularizers stack: Int or iterable. Selects which layers of the core should be stacked for the readout. default value will stack all layers on top of each other. @@ -204,7 +204,7 @@ def __init__( input_kern: kernel size of the first layer (i.e. the input layer) hidden_kern: kernel size of each hidden layer's kernel layers: number of layers - gamma_input: regularizer factor for the input weights (default: LaplaceL2, see mlutils.regularizers) + gamma_input: regularizer factor for the input weights (default: LaplaceL2, see neuralpredictors.regularizers) skip: Adds a skip connection final_nonlinearity: Boolean, if true, appends an ELU layer after the last BatchNorm (if BN=True) bias: Adds a bias layer. Note: bias and batch_norm can not both be true @@ -216,7 +216,7 @@ def __init__( the kernel size (recommended). Setting Padding to 0 is not recommended and leads to artefacts, zero is the default however to recreate backwards compatibility. normalize_laplace_regularizer: Boolean, if set to True, will use the LaplaceL2norm function from - mlutils.regularizers, which returns the regularizer as |laplace(filters)| / |filters| + neuralpredictors.regularizers, which returns the regularizer as |laplace(filters)| / |filters| input_regularizer: String that must match one of the regularizers in ..regularizers stack: Int or iterable. Selects which layers of the core should be stacked for the readout. default value will stack all layers on top of each other. @@ -359,7 +359,7 @@ def se_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, depth_separable=False, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -367,8 +367,8 @@ def se_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -404,7 +404,7 @@ def regularizer(self, data_key): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = SE2dCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, @@ -451,7 +451,7 @@ def ds_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, gamma_readout=4, elu_offset=0, stack=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -459,8 +459,8 @@ def ds_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -496,7 +496,7 @@ def regularizer(self, data_key): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = DepthSeparableCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, @@ -540,7 +540,7 @@ def ds_core_point_readout(dataloaders, seed, hidden_channels=32, input_kern=13, init_range=0.2, gamma_readout=0.1, elu_offset=0, stack=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -548,8 +548,8 @@ def ds_core_point_readout(dataloaders, seed, hidden_channels=32, input_kern=13, seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -583,7 +583,7 @@ def regularizer(self, data_key): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = DepthSeparableCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, @@ -627,7 +627,7 @@ def stacked2d_core_gaussian_readout(dataloaders, seed, hidden_channels=32, input gamma_readout=0.1, elu_offset=0, stack=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -635,8 +635,8 @@ def stacked2d_core_gaussian_readout(dataloaders, seed, hidden_channels=32, input seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -670,7 +670,7 @@ def regularizer(self, data_key): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = Stacked2dCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, diff --git a/nnvision/legacy/nnfabrik/models/pretrained_models.py b/nnvision/legacy/nnfabrik/models/pretrained_models.py index fb35efe6..0681d5f2 100644 --- a/nnvision/legacy/nnfabrik/models/pretrained_models.py +++ b/nnvision/legacy/nnfabrik/models/pretrained_models.py @@ -1,5 +1,5 @@ -from mlutils.layers.readouts import PointPooled2d -from mlutils.layers.cores import Core2d, Core +from neuralpredictors.layers.readouts import PointPooled2d +from neuralpredictors.layers.cores import Core2d, Core from ..utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict from itertools import count diff --git a/nnvision/legacy/nnfabrik/models/v1_models.py b/nnvision/legacy/nnfabrik/models/v1_models.py index a95311cf..b109901a 100644 --- a/nnvision/legacy/nnfabrik/models/v1_models.py +++ b/nnvision/legacy/nnfabrik/models/v1_models.py @@ -2,9 +2,9 @@ from torch import nn as nn from torch.nn import functional as F -from mlutils.layers.readouts import PointPooled2d -from mlutils.layers.cores import Stacked2dCore -from mlutils.training import eval_state +from neuralpredictors.layers.readouts import PointPooled2d +from neuralpredictors.layers.cores import Stacked2dCore +from neuralpredictors.training import eval_state from .pretrained_models import TransferLearningCore from ..utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict @@ -47,7 +47,7 @@ def stacked2d_core_point_readout(dataloaders, seed, hidden_channels=32, input_ke gamma_readout=0.1, elu_offset=0, stack=None, readout_reg_avg=False, use_avg_reg=False): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -55,8 +55,8 @@ def stacked2d_core_point_readout(dataloaders, seed, hidden_channels=32, input_ke seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -109,7 +109,7 @@ def tracked_values(self): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = Stacked2dCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, diff --git a/nnvision/legacy/nnfabrik/training/dynamic_trainers.py b/nnvision/legacy/nnfabrik/training/dynamic_trainers.py index 48d549a3..084af4ab 100644 --- a/nnvision/legacy/nnfabrik/training/dynamic_trainers.py +++ b/nnvision/legacy/nnfabrik/training/dynamic_trainers.py @@ -1,6 +1,6 @@ from collections import namedtuple -from mlutils.measures import PoissonLoss3d +from neuralpredictors.measures import PoissonLoss3d def slice_iter(n, step): diff --git a/nnvision/legacy/nnfabrik/training/dynamic_training/__init__.py b/nnvision/legacy/nnfabrik/training/dynamic_training/__init__.py index bc8c10e6..3c32f083 100644 --- a/nnvision/legacy/nnfabrik/training/dynamic_training/__init__.py +++ b/nnvision/legacy/nnfabrik/training/dynamic_training/__init__.py @@ -1,4 +1,4 @@ -from mlutils.measures import PoissonLoss3d +from neuralpredictors.measures import PoissonLoss3d from .utils import ( corr, ptcorr, @@ -8,7 +8,7 @@ correlation_closure, compute_scores, ) -from mlutils.training import cycle_datasets, early_stopping +from neuralpredictors.training import cycle_datasets, early_stopping from tqdm import tqdm from logging import getLogger from itertools import product, repeat diff --git a/nnvision/legacy/nnfabrik/training/trainers.py b/nnvision/legacy/nnfabrik/training/trainers.py index 213597e8..928d1bed 100644 --- a/nnvision/legacy/nnfabrik/training/trainers.py +++ b/nnvision/legacy/nnfabrik/training/trainers.py @@ -6,9 +6,9 @@ from scipy import stats from tqdm import tqdm -from mlutils import measures -from mlutils.measures import * -from mlutils.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler +from neuralpredictors import measures +from neuralpredictors.measures import * +from neuralpredictors.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler from ..utility.nn_helpers import set_random_seed from ..utility import metrics @@ -32,7 +32,7 @@ def early_stop_trainer(model, seed, stop_function='corr_stop', 'exp_stop' 'poisson_stop' loss_function: has to be a string that gets evaluated with eval() - Loss functions that are built in at mlutils that can + Loss functions that are built in at neuralpredictors that can be selected in the trainer config are: 'PoissonLoss' 'GammaLoss' diff --git a/nnvision/legacy/nnfabrik/utility/metrics.py b/nnvision/legacy/nnfabrik/utility/metrics.py index e8a20bee..8085d20c 100644 --- a/nnvision/legacy/nnfabrik/utility/metrics.py +++ b/nnvision/legacy/nnfabrik/utility/metrics.py @@ -4,8 +4,8 @@ import torch from scipy import stats -from mlutils.measures import PoissonLoss, corr -from mlutils.training import eval_state +from neuralpredictors.measures import PoissonLoss, corr +from neuralpredictors.training import eval_state def model_predictions(loader, model, data_key, device): diff --git a/nnvision/legacy/nnfabrik/utility/nn_helpers.py b/nnvision/legacy/nnfabrik/utility/nn_helpers.py index a1f23631..776c6fe7 100644 --- a/nnvision/legacy/nnfabrik/utility/nn_helpers.py +++ b/nnvision/legacy/nnfabrik/utility/nn_helpers.py @@ -1,7 +1,7 @@ # helper functions concerning the ANN architecture import torch -from mlutils.training import eval_state +from neuralpredictors.training import eval_state import numpy as np import random diff --git a/nnvision/models/cores.py b/nnvision/models/cores.py index 087081a5..c0d6cb7b 100644 --- a/nnvision/models/cores.py +++ b/nnvision/models/cores.py @@ -2,9 +2,9 @@ import torch from torch import nn as nn -from mlutils.layers.attention import AttentionConv -from mlutils.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore -from mlutils import regularizers +from neuralpredictors.layers.attention import AttentionConv +from neuralpredictors.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore +from neuralpredictors import regularizers from .architectures import SQ_EX_Block from torch.nn import functional as F @@ -124,7 +124,7 @@ def __init__( input_kern: kernel size of the first layer (i.e. the input layer) hidden_kern: kernel size of each hidden layer's kernel layers: number of layers - gamma_input: regularizer factor for the input weights (default: LaplaceL2, see mlutils.regularizers) + gamma_input: regularizer factor for the input weights (default: LaplaceL2, see neuralpredictors.regularizers) skip: Adds a skip connection final_nonlinearity: Boolean, if true, appends an ELU layer after the last BatchNorm (if BN=True) bias: Adds a bias layer. Note: bias and batch_norm can not both be true @@ -136,7 +136,7 @@ def __init__( the kernel size (recommended). Setting Padding to 0 is not recommended and leads to artefacts, zero is the default however to recreate backwards compatibility. normalize_laplace_regularizer: Boolean, if set to True, will use the LaplaceL2norm function from - mlutils.regularizers, which returns the regularizer as |laplace(filters)| / |filters| + neuralpredictors.regularizers, which returns the regularizer as |laplace(filters)| / |filters| input_regularizer: String that must match one of the regularizers in ..regularizers stack: Int or iterable. Selects which layers of the core should be stacked for the readout. default value will stack all layers on top of each other. diff --git a/nnvision/models/models.py b/nnvision/models/models.py index 3d079259..d716ee0d 100644 --- a/nnvision/models/models.py +++ b/nnvision/models/models.py @@ -2,13 +2,13 @@ import torch import copy -from mlutils.layers.cores import Stacked2dCore -from mlutils.layers.legacy import Gaussian2d -from mlutils.layers.readouts import PointPooled2d, FullGaussian2d -from mlutils.layers.activations import MultiplePiecewiseLinearExpNonlinearity +from neuralpredictors.layers.cores import Stacked2dCore +from neuralpredictors.layers.legacy import Gaussian2d +from neuralpredictors.layers.readouts import PointPooled2d, FullGaussian2d +from neuralpredictors.layers.activations import MultiplePiecewiseLinearExpNonlinearity from nnfabrik.builder import get_model -from nnfabrik.utility.nn_helpers import get_module_output, set_random_seed, get_dims_for_loader_dict +from nnfabrik.utility.nn_helpers import set_random_seed, get_dims_for_loader_dict from torch import nn from torch.nn import functional as F @@ -36,7 +36,7 @@ def se_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, depth_separable=False, linear=False, data_info=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -44,8 +44,8 @@ def se_core_gauss_readout(dataloaders, seed, hidden_channels=32, input_kern=13, seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -158,7 +158,7 @@ def se_core_full_gauss_readout(dataloaders, gamma_grid_dispersion=0, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -178,8 +178,8 @@ def se_core_full_gauss_readout(dataloaders, share_features: whether to share features between readouts. This requires that the datasets have the properties `neurons.multi_match_id` which are used for matching. Every dataset has to have all these ids and cannot have any more. - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -298,7 +298,7 @@ def se_core_point_readout(dataloaders, seed, hidden_channels=32, input_kern=13, depth_separable=False, linear=False, data_info=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -306,8 +306,8 @@ def se_core_point_readout(dataloaders, seed, hidden_channels=32, input_kern=13, seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -396,7 +396,7 @@ def stacked2d_core_gaussian_readout(dataloaders, seed, hidden_channels=32, input gamma_readout=0.1, elu_offset=0, stack=None, isotropic=True, data_info=None, ): """ - Model class of a stacked2dCore (from mlutils) and a pointpooled (spatial transformer) readout + Model class of a stacked2dCore (from neuralpredictors) and a pointpooled (spatial transformer) readout Args: dataloaders: a dictionary of dataloaders, one loader per session @@ -404,8 +404,8 @@ def stacked2d_core_gaussian_readout(dataloaders, seed, hidden_channels=32, input seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores and - PointPooled2D in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores and + PointPooled2D in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core and model.readout """ @@ -665,7 +665,7 @@ def se_core_spatialXfeature_readout(dataloaders, seed, hidden_channels=32, input gamma_readout=4, normalize=False, elu_offset=0, stack=None, se_reduction=32, n_se_blocks=1, depth_separable=False, linear=False, data_info=None): """ - Model class of a stacked2dCore (from mlutils) and a spatialXfeature (factorized) readout + Model class of a stacked2dCore (from neuralpredictors) and a spatialXfeature (factorized) readout Args: @@ -1079,14 +1079,14 @@ def stacked2d_core_dn_linear_readout(dataloaders, seed, hidden_channels=32, inpu final_nonlin=False, nonlin_bias=True, nonlin_initial_value=0.01, vmin=-3, vmax=6, num_bins=50, smooth_reg_weight=0, smoothnes_reg_order=2): """ - Model class of a stacked2dCore (from mlutils), a divisive normalization layer and a SpatialXFeatureLinear readout + Model class of a stacked2dCore (from neuralpredictors), a divisive normalization layer and a SpatialXFeatureLinear readout Args: dataloaders: a dictionary of dataloaders, one loader per session in the format {'data_key': dataloader object, .. } seed: random seed elu_offset: Offset for the output non-linearity [F.elu(x + self.offset)] - all other args: See Documentation of Stacked2dCore in mlutils.layers.cores, divisive_normalization and - SpatialXFeatureLinear in mlutils.layers.readouts + all other args: See Documentation of Stacked2dCore in neuralpredictors.layers.cores, divisive_normalization and + SpatialXFeatureLinear in neuralpredictors.layers.readouts Returns: An initialized model which consists of model.core, model.dn and model.readout (depending on args: model.nonlin) Thus the divisive normalization code is private, it is stored in a different repo (divn), which must be installed to build this model. @@ -1156,7 +1156,7 @@ def tracked_values(self): set_random_seed(seed) - # get a stacked2D core from mlutils + # get a stacked2D core from neuralpredictors core = Stacked2dCore(input_channels=input_channels[0], hidden_channels=hidden_channels, input_kern=input_kern, diff --git a/nnvision/models/ptrmodels.py b/nnvision/models/ptrmodels.py index de8edb0f..f6b37350 100644 --- a/nnvision/models/ptrmodels.py +++ b/nnvision/models/ptrmodels.py @@ -2,17 +2,18 @@ import torch import copy -from mlutils.layers.cores import Stacked2dCore -from mlutils.layers.legacy import Gaussian2d -from mlutils.layers.readouts import PointPooled2d -from nnfabrik.utility.nn_helpers import get_module_output, set_random_seed, get_dims_for_loader_dict +from neuralpredictors.layers.cores import Stacked2dCore +from neuralpredictors.layers.legacy import Gaussian2d +from neuralpredictors.layers.readouts import PointPooled2d +from nnvision.legacy.nnfabrik.utility.nn_helpers import get_module_output +from nnfabrik.utility.nn_helpers import set_random_seed, get_dims_for_loader_dict from torch import nn from torch.nn import functional as F from .readouts import MultipleFullGaussian2d, MultiReadout, MultipleSpatialXFeatureLinear from .utility import unpack_data_info -from ptrnets.cores.cores import TaskDrivenCore, TaskDrivenCore2 +# from ptrnets.cores.cores import TaskDrivenCore, TaskDrivenCore2 class Encoder(nn.Module): diff --git a/nnvision/models/readouts.py b/nnvision/models/readouts.py index 5ea6e828..060e0977 100644 --- a/nnvision/models/readouts.py +++ b/nnvision/models/readouts.py @@ -1,18 +1,18 @@ import torch from torch import nn -from nnfabrik.utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict +from nnvision.legacy.nnfabrik.utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict from collections import OrderedDict, Iterable import numpy as np import warnings from torch.nn import Parameter from torch.nn import functional as F from torch.nn import ModuleDict -from mlutils.constraints import positive -from mlutils.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore -from mlutils import regularizers -from mlutils.layers.readouts import PointPooled2d, FullGaussian2d, SpatialXFeatureLinear -from mlutils.layers.legacy import Gaussian2d +from neuralpredictors.constraints import positive +from neuralpredictors.layers.cores import DepthSeparableConv2d, Core2d, Stacked2dCore +from neuralpredictors import regularizers +from neuralpredictors.layers.readouts import PointPooled2d, FullGaussian2d, SpatialXFeatureLinear +from neuralpredictors.layers.legacy import Gaussian2d class MultiplePointPooled2d(torch.nn.ModuleDict): @@ -151,7 +151,7 @@ def __init__(self, core, in_shape_dict, n_neurons_dict, init_mu_range, init_sigm def regularizer(self, data_key): if hasattr(FullGaussian2d, 'mu_dispersion'): return self[data_key].feature_l1(average=False) * self.gamma_readout \ - + self[data_key].mu_dispersion() * self.gamma_grid_dispersion + + self[data_key].mu_dispersion * self.gamma_grid_dispersion else: return self[data_key].feature_l1(average=False) * self.gamma_readout diff --git a/nnvision/models/utility.py b/nnvision/models/utility.py index 9370160e..2892e362 100644 --- a/nnvision/models/utility.py +++ b/nnvision/models/utility.py @@ -1,8 +1,8 @@ import torch import copy -import mlutils -from mlutils.layers.readouts import PointPooled2d, FullGaussian2d -from mlutils.layers.legacy import Gaussian2d +import neuralpredictors +from neuralpredictors.layers.readouts import PointPooled2d, FullGaussian2d +from neuralpredictors.layers.legacy import Gaussian2d def unpack_data_info(data_info): diff --git a/nnvision/tables/legacy/from_mei.py b/nnvision/tables/legacy/from_mei.py index 5ccc90bd..74ae7e08 100644 --- a/nnvision/tables/legacy/from_mei.py +++ b/nnvision/tables/legacy/from_mei.py @@ -2,7 +2,7 @@ from nnvision.legacy.featurevis.main import TrainedEnsembleModelTemplate, MEITemplate from nnfabrik.main import Dataset from nnvision.tables.from_nnfabrik import TrainedModel -from mlutils.data.datasets import StaticImageSet, FileTreeDataset +from neuralpredictors.data.datasets import StaticImageSet, FileTreeDataset from nnvision.legacy.featurevis import integration from nnvision.mei.helpers import get_neuron_mappings from nnfabrik.utility.dj_helpers import make_hash diff --git a/nnvision/training/legacy_trainers.py b/nnvision/training/legacy_trainers.py index 08b283fd..b524f669 100644 --- a/nnvision/training/legacy_trainers.py +++ b/nnvision/training/legacy_trainers.py @@ -6,8 +6,8 @@ import torch from tqdm import tqdm -from mlutils.measures import * -from mlutils.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler +from neuralpredictors.measures import * +from neuralpredictors.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler from nnfabrik.utility.nn_helpers import set_random_seed from ..utility import measures @@ -31,7 +31,7 @@ def early_stop_trainer(model, seed, stop_function='get_correlations', 'exp_stop' 'poisson_stop' loss_function: has to be a string that gets evaluated with eval() - Loss functions that are built in at mlutils that can + Loss functions that are built in at neuralpredictors that can be selected in the trainer config are: 'PoissonLoss' 'GammaLoss' diff --git a/nnvision/training/trainers.py b/nnvision/training/trainers.py index f4e3cb1f..0fac23f3 100644 --- a/nnvision/training/trainers.py +++ b/nnvision/training/trainers.py @@ -5,9 +5,9 @@ import torch from tqdm import tqdm -from mlutils.measures import * -from mlutils import measures as mlmeasures -from mlutils.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler +from neuralpredictors.measures import * +from neuralpredictors import measures as mlmeasures +from neuralpredictors.training import early_stopping, MultipleObjectiveTracker, eval_state, cycle_datasets, Exhauster, LongCycler from nnfabrik.utility.nn_helpers import set_random_seed from ..utility import measures diff --git a/nnvision/utility/data_helpers.py b/nnvision/utility/data_helpers.py index 47e2ec3e..ed839407 100644 --- a/nnvision/utility/data_helpers.py +++ b/nnvision/utility/data_helpers.py @@ -1,8 +1,8 @@ -from mlutils.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels, SelectInputChannel +from neuralpredictors.data.transforms import Subsample, ToTensor, NeuroNormalizer, AddBehaviorAsChannels, SelectInputChannel import numpy as np from torch.utils.data import DataLoader -from mlutils.data.datasets import StaticImageSet -from mlutils.data.samplers import RepeatsBatchSampler +from neuralpredictors.data.datasets import StaticImageSet +from neuralpredictors.data.samplers import RepeatsBatchSampler def get_oracle_dataloader(paths=None, seed=None, area='V1', layer='L2/3', diff --git a/nnvision/utility/measures.py b/nnvision/utility/measures.py index ec0be3c9..dc679f3c 100644 --- a/nnvision/utility/measures.py +++ b/nnvision/utility/measures.py @@ -1,8 +1,8 @@ import warnings import numpy as np import torch -from mlutils.measures import corr -from mlutils.training import eval_state, device_state +from neuralpredictors.measures import corr +from neuralpredictors.training import eval_state, device_state import types import contextlib from nnvision.utility.measure_helpers import is_ensemble_function diff --git a/notebooks/Extend_Data_Filetree.ipynb b/notebooks/Extend_Data_Filetree.ipynb index f0907533..5799a1fc 100644 --- a/notebooks/Extend_Data_Filetree.ipynb +++ b/notebooks/Extend_Data_Filetree.ipynb @@ -34,7 +34,7 @@ "\n", "#import dataport\n", "#from dataport.bcm import experiment, xmatch, stack\n", - "from mlutils.data.datasets import FileTreeDataset\n", + "from neuralpredictors.data.datasets import FileTreeDataset\n", "from pathlib import Path\n", "import numpy as np\n", "import h5py\n", diff --git a/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb b/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb index f6ab2297..fe825167 100644 --- a/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb +++ b/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb @@ -52,8 +52,8 @@ "import seaborn as sns\n", "from pathlib import Path\n", "import itertools\n", - "from mlutils.data.datasets import FileTreeDataset\n", - "from mlutils.data.samplers import RepeatsBatchSampler\n", + "from neuralpredictors.data.datasets import FileTreeDataset\n", + "from neuralpredictors.data.samplers import RepeatsBatchSampler\n", "from torch.utils.data import DataLoader" ] }, From 0c023953fb842ee8fd02b3640d14a05686aadc7b Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Sun, 3 Oct 2021 11:23:09 +0200 Subject: [PATCH 2/9] last master commit --- notebooks/monkey_demo_my_nnfabrik.ipynb | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/notebooks/monkey_demo_my_nnfabrik.ipynb b/notebooks/monkey_demo_my_nnfabrik.ipynb index a043884b..db5cf6ee 100644 --- a/notebooks/monkey_demo_my_nnfabrik.ipynb +++ b/notebooks/monkey_demo_my_nnfabrik.ipynb @@ -46,7 +46,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%okjk\n" + } + }, "outputs": [], "source": [ "import datajoint as dj\n", @@ -743,4 +747,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file From 6e450ecce82062961e10542d132cfcbbac925928 Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Wed, 6 Oct 2021 16:08:15 +0200 Subject: [PATCH 3/9] Added dataloader, TrialWiseDataset, initialization works --- nnvision/datasets/monkey_loaders.py | 1 - 1 file changed, 1 deletion(-) diff --git a/nnvision/datasets/monkey_loaders.py b/nnvision/datasets/monkey_loaders.py index 053d1687..1f372f72 100644 --- a/nnvision/datasets/monkey_loaders.py +++ b/nnvision/datasets/monkey_loaders.py @@ -176,7 +176,6 @@ def monkey_static_loader(dataset, dataloaders["validation"][data_key] = val_loader dataloaders["test"][data_key] = test_loader - if store_data_info and not os.path.exists(stats_path): in_name, out_name = next(iter(list(dataloaders["train"].values())[0]))._fields From 4f27c44eeb3147fdb773edddf8c4af8291bdd320 Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Fri, 8 Oct 2021 13:15:25 +0200 Subject: [PATCH 4/9] [ADD] test_dataset script finished, added ln_model to test if dataloader works --- nnvision/models/ptrmodels.py | 3 ++- nnvision/models/readouts.py | 2 +- nnvision/utility/measures.py | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/nnvision/models/ptrmodels.py b/nnvision/models/ptrmodels.py index f6b37350..e5b92690 100644 --- a/nnvision/models/ptrmodels.py +++ b/nnvision/models/ptrmodels.py @@ -5,8 +5,9 @@ from neuralpredictors.layers.cores import Stacked2dCore from neuralpredictors.layers.legacy import Gaussian2d from neuralpredictors.layers.readouts import PointPooled2d -from nnvision.legacy.nnfabrik.utility.nn_helpers import get_module_output +from ..legacy.nnfabrik.utility.nn_helpers import get_module_output from nnfabrik.utility.nn_helpers import set_random_seed, get_dims_for_loader_dict + from torch import nn from torch.nn import functional as F diff --git a/nnvision/models/readouts.py b/nnvision/models/readouts.py index 060e0977..b2cb6876 100644 --- a/nnvision/models/readouts.py +++ b/nnvision/models/readouts.py @@ -1,7 +1,7 @@ import torch from torch import nn -from nnvision.legacy.nnfabrik.utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict +from ..legacy.nnfabrik.utility.nn_helpers import get_io_dims, get_module_output, set_random_seed, get_dims_for_loader_dict from collections import OrderedDict, Iterable import numpy as np import warnings diff --git a/nnvision/utility/measures.py b/nnvision/utility/measures.py index dc679f3c..ee0c5395 100644 --- a/nnvision/utility/measures.py +++ b/nnvision/utility/measures.py @@ -5,7 +5,7 @@ from neuralpredictors.training import eval_state, device_state import types import contextlib -from nnvision.utility.measure_helpers import is_ensemble_function +from submodules.nnvision.nnvision.utility.measure_helpers import is_ensemble_function import warnings from .measure_helpers import get_subset_of_repeats From 2c00f210a10fb1937ad59fbde5333c06b07a617f Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Wed, 13 Oct 2021 13:35:23 +0200 Subject: [PATCH 5/9] [ADD] transorming dataloader into reading whole trials --- nnvision/models/readouts.py | 4 ++-- nnvision/utility/measures.py | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/nnvision/models/readouts.py b/nnvision/models/readouts.py index b2cb6876..40479289 100644 --- a/nnvision/models/readouts.py +++ b/nnvision/models/readouts.py @@ -150,8 +150,8 @@ def __init__(self, core, in_shape_dict, n_neurons_dict, init_mu_range, init_sigm def regularizer(self, data_key): if hasattr(FullGaussian2d, 'mu_dispersion'): - return self[data_key].feature_l1(average=False) * self.gamma_readout \ - + self[data_key].mu_dispersion * self.gamma_grid_dispersion + return self[data_key].feature_l1(average=False) * self.gamma_readout + # + self[data_key].mu_dispersion() * self.gamma_grid_dispersion else: return self[data_key].feature_l1(average=False) * self.gamma_readout diff --git a/nnvision/utility/measures.py b/nnvision/utility/measures.py index ee0c5395..736def67 100644 --- a/nnvision/utility/measures.py +++ b/nnvision/utility/measures.py @@ -88,6 +88,7 @@ def get_avg_correlations(model, dataloaders, device='cpu', as_dict=False, per_ne if not as_dict: correlations = np.hstack([v for v in correlations.values()]) if per_neuron else np.mean(np.hstack([v for v in correlations.values()])) + # print(dataloaders[dataloaders.keys()[0]].__getitem__.cache_info()) return correlations From 36d582e0a1aad033cba1d39a787ea5ccd5c50b5b Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Mon, 25 Oct 2021 10:01:09 +0200 Subject: [PATCH 6/9] [ADD] Weight initialization based on receptive field added to 3D convolution --- nnvision/models/readouts.py | 1 + nnvision/training/trainers.py | 7 +++++-- nnvision/utility/measures.py | 5 ++++- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/nnvision/models/readouts.py b/nnvision/models/readouts.py index 40479289..a0459fd1 100644 --- a/nnvision/models/readouts.py +++ b/nnvision/models/readouts.py @@ -106,6 +106,7 @@ def __init__(self, core, in_shape_dict, n_neurons_dict, init_mu_range, init_sigm # super init to get the _module attribute super().__init__() k0 = None + for i, k in enumerate(n_neurons_dict): k0 = k0 or k in_shape = get_module_output(core, in_shape_dict[k])[1:] diff --git a/nnvision/training/trainers.py b/nnvision/training/trainers.py index 0fac23f3..dce94dde 100644 --- a/nnvision/training/trainers.py +++ b/nnvision/training/trainers.py @@ -74,13 +74,14 @@ def full_objective(model, dataloader, data_key, *args): model.to(device) set_random_seed(seed) model.train() + loss_value = None criterion = getattr(mlmeasures, loss_function)(avg=avg_loss) stop_closure = partial(getattr(measures, stop_function), dataloaders=dataloaders["validation"], device=device, per_neuron=False, avg=True) n_iterations = len(LongCycler(dataloaders["train"])) - optimizer = torch.optim.Adam(model.parameters(), lr=lr_init) + optimizer = torch.optim.Adam(model.parameters(), lr=lr_init, weight_decay=0.01) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max' if maximize else 'min', factor=lr_decay_factor, patience=patience, threshold=tolerance, @@ -121,9 +122,11 @@ def full_objective(model, dataloader, data_key, *args): loss = full_objective(model, dataloaders["train"], data_key, *data) loss.backward() + loss_value = loss if (batch_no + 1) % optim_step_count == 0: optimizer.step() optimizer.zero_grad() + print(f'loss value: {loss_value}') ##### Model evaluation #################################################################################################### model.eval() @@ -132,7 +135,7 @@ def full_objective(model, dataloader, data_key, *args): # Compute avg validation and test correlation validation_correlation = get_correlations(model, dataloaders["validation"], device=device, as_dict=False, per_neuron=False) test_correlation = get_correlations(model, dataloaders["test"], device=device, as_dict=False, per_neuron=False) - + print(f'loss value: {loss_value}') # return the whole tracker output as a dict output = {k: v for k, v in tracker.log.items()} if track_training else {} output["validation_corr"] = validation_correlation diff --git a/nnvision/utility/measures.py b/nnvision/utility/measures.py index 736def67..c7295951 100644 --- a/nnvision/utility/measures.py +++ b/nnvision/utility/measures.py @@ -88,15 +88,18 @@ def get_avg_correlations(model, dataloaders, device='cpu', as_dict=False, per_ne if not as_dict: correlations = np.hstack([v for v in correlations.values()]) if per_neuron else np.mean(np.hstack([v for v in correlations.values()])) - # print(dataloaders[dataloaders.keys()[0]].__getitem__.cache_info()) + return correlations def get_correlations(model, dataloaders, device='cpu', as_dict=False, per_neuron=True, **kwargs): correlations = {} + with eval_state(model) if not is_ensemble_function(model) else contextlib.nullcontext(): for k, v in dataloaders.items(): target, output = model_predictions(dataloader=v, model=model, data_key=k, device=device) + print('target:', target) + print('output:', output) correlations[k] = corr(target, output, axis=0) if np.any(np.isnan(correlations[k])): From 3c69319f7182b941ab50557869921f10e197f0b3 Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Tue, 26 Oct 2021 15:32:35 +0200 Subject: [PATCH 7/9] [ADD] Weight initialization based on receptive field added to 3D convolution --- nnvision/training/trainers.py | 1 + 1 file changed, 1 insertion(+) diff --git a/nnvision/training/trainers.py b/nnvision/training/trainers.py index dce94dde..d54625a2 100644 --- a/nnvision/training/trainers.py +++ b/nnvision/training/trainers.py @@ -123,6 +123,7 @@ def full_objective(model, dataloader, data_key, *args): loss = full_objective(model, dataloaders["train"], data_key, *data) loss.backward() loss_value = loss + # print(f'grad: {model.readout._modules[list(model.readout._modules.keys())[0]].conv.weight.grad[0, 0, :10, :10]}') if (batch_no + 1) % optim_step_count == 0: optimizer.step() optimizer.zero_grad() From 93f39ff2e3ec43392ed9a0900c6ea6b32622a272 Mon Sep 17 00:00:00 2001 From: Michaela Vystrcilova Date: Fri, 29 Oct 2021 10:18:28 +0200 Subject: [PATCH 8/9] [FIX] Fixed bug with simple ln model not training --- nnvision/training/trainers.py | 4 +++- nnvision/utility/measures.py | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/nnvision/training/trainers.py b/nnvision/training/trainers.py index d54625a2..f12dced3 100644 --- a/nnvision/training/trainers.py +++ b/nnvision/training/trainers.py @@ -76,7 +76,7 @@ def full_objective(model, dataloader, data_key, *args): model.train() loss_value = None - criterion = getattr(mlmeasures, loss_function)(avg=avg_loss) + criterion = getattr(mlmeasures, loss_function)(avg=avg_loss, per_neuron=False) stop_closure = partial(getattr(measures, stop_function), dataloaders=dataloaders["validation"], device=device, per_neuron=False, avg=True) n_iterations = len(LongCycler(dataloaders["train"])) @@ -121,7 +121,9 @@ def full_objective(model, dataloader, data_key, *args): desc="Epoch {}".format(epoch)): loss = full_objective(model, dataloaders["train"], data_key, *data) + # loss = torch.sum(loss) loss.backward() + # torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1, norm_type=2) loss_value = loss # print(f'grad: {model.readout._modules[list(model.readout._modules.keys())[0]].conv.weight.grad[0, 0, :10, :10]}') if (batch_no + 1) % optim_step_count == 0: diff --git a/nnvision/utility/measures.py b/nnvision/utility/measures.py index c7295951..776e1a38 100644 --- a/nnvision/utility/measures.py +++ b/nnvision/utility/measures.py @@ -59,7 +59,7 @@ def model_predictions(model, dataloader, data_key, device='cpu'): responses = responses.squeeze(dim=0) with eval_state(model) if not is_ensemble_function(model) else contextlib.nullcontext(): with device_state(model, device) if not is_ensemble_function(model) else contextlib.nullcontext(): - output = torch.cat((output, (model(images.to(device), data_key=data_key).detach().cpu())), dim=0) + output = torch.cat((output, (torch.squeeze(torch.squeeze(model(images.to(device), data_key=data_key).detach().cpu(), dim=2), dim=2))), dim=0) target = torch.cat((target, responses.detach().cpu()), dim=0) return target.numpy(), output.numpy() @@ -98,6 +98,7 @@ def get_correlations(model, dataloaders, device='cpu', as_dict=False, per_neuron with eval_state(model) if not is_ensemble_function(model) else contextlib.nullcontext(): for k, v in dataloaders.items(): target, output = model_predictions(dataloader=v, model=model, data_key=k, device=device) + # output = np.expand_dims(output, axis=1) print('target:', target) print('output:', output) correlations[k] = corr(target, output, axis=0) @@ -116,6 +117,7 @@ def get_poisson_loss(model, dataloaders, device='cpu', as_dict=False, avg=False, with eval_state(model) if not is_ensemble_function(model) else contextlib.nullcontext(): for k, v in dataloaders.items(): target, output = model_predictions(dataloader=v, model=model, data_key=k, device=device) + # output = torch.unsqueeze(output, dim=1) loss = output - target * np.log(output + eps) poisson_loss[k] = np.mean(loss, axis=0) if avg else np.sum(loss, axis=0) if as_dict: From 1388be61c1fd41f237b59e8fd0f9519b4f4619bc Mon Sep 17 00:00:00 2001 From: KonstantinWilleke Date: Wed, 7 Sep 2022 15:34:15 +0200 Subject: [PATCH 9/9] refactor notebooks. --- notebooks/Demos/data/__init__.py | 0 .../data}/create_images_cached_loader.ipynb | 0 .../monkey}/Bayes_Hypersearch_Demo.ipynb | 0 ...o_Express_loading_and_scoring_tables.ipynb | 0 notebooks/Demos/monkey/__init__.py | 0 .../{ => Demos/monkey}/monkey_demo.ipynb | 0 .../monkey}/monkey_demo_my_nnfabrik.ipynb | 0 .../{ => monkey}/nnfabrik_insilico.ipynb | 0 .../{ => Demos/monkey}/nnvision_demo.ipynb | 0 .../mouse}/Extend_Data_Filetree.ipynb | 0 .../mouse}/FileTreeSet_training_demo.ipynb | 0 .../{ => Demos/mouse}/Mouse_Example.ipynb | 0 ...ex Mapped Readout on FileTreeDataset.ipynb | 8 +- notebooks/Demos/mouse/__init__.py | 0 .../plots/Analyses/Best_MEI_textures.ipynb | 1066 ----------------- .../Monkey_V1_V4_explainable_variance.ipynb | 161 --- .../Monkey_V1_V4_explainable_variance.pdf | Bin 12259 -> 0 bytes ...le_variance_bootstrapped_generalized.ipynb | 236 ---- 18 files changed, 6 insertions(+), 1465 deletions(-) create mode 100644 notebooks/Demos/data/__init__.py rename notebooks/{ => Demos/data}/create_images_cached_loader.ipynb (100%) rename notebooks/{ => Demos/monkey}/Bayes_Hypersearch_Demo.ipynb (100%) rename notebooks/{ => Demos/monkey}/Demo_Express_loading_and_scoring_tables.ipynb (100%) create mode 100644 notebooks/Demos/monkey/__init__.py rename notebooks/{ => Demos/monkey}/monkey_demo.ipynb (100%) rename notebooks/{ => Demos/monkey}/monkey_demo_my_nnfabrik.ipynb (100%) rename notebooks/Demos/{ => monkey}/nnfabrik_insilico.ipynb (100%) rename notebooks/{ => Demos/monkey}/nnvision_demo.ipynb (100%) rename notebooks/{ => Demos/mouse}/Extend_Data_Filetree.ipynb (100%) rename notebooks/{ => Demos/mouse}/FileTreeSet_training_demo.ipynb (100%) rename notebooks/{ => Demos/mouse}/Mouse_Example.ipynb (100%) rename notebooks/{ => Demos/mouse}/Train Cortex Mapped Readout on FileTreeDataset.ipynb (99%) create mode 100644 notebooks/Demos/mouse/__init__.py delete mode 100644 notebooks/plots/Analyses/Best_MEI_textures.ipynb delete mode 100644 notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.ipynb delete mode 100644 notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.pdf delete mode 100644 notebooks/plots/descriptive_statistics/explainable_variance_bootstrapped_generalized.ipynb diff --git a/notebooks/Demos/data/__init__.py b/notebooks/Demos/data/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/notebooks/create_images_cached_loader.ipynb b/notebooks/Demos/data/create_images_cached_loader.ipynb similarity index 100% rename from notebooks/create_images_cached_loader.ipynb rename to notebooks/Demos/data/create_images_cached_loader.ipynb diff --git a/notebooks/Bayes_Hypersearch_Demo.ipynb b/notebooks/Demos/monkey/Bayes_Hypersearch_Demo.ipynb similarity index 100% rename from notebooks/Bayes_Hypersearch_Demo.ipynb rename to notebooks/Demos/monkey/Bayes_Hypersearch_Demo.ipynb diff --git a/notebooks/Demo_Express_loading_and_scoring_tables.ipynb b/notebooks/Demos/monkey/Demo_Express_loading_and_scoring_tables.ipynb similarity index 100% rename from notebooks/Demo_Express_loading_and_scoring_tables.ipynb rename to notebooks/Demos/monkey/Demo_Express_loading_and_scoring_tables.ipynb diff --git a/notebooks/Demos/monkey/__init__.py b/notebooks/Demos/monkey/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/notebooks/monkey_demo.ipynb b/notebooks/Demos/monkey/monkey_demo.ipynb similarity index 100% rename from notebooks/monkey_demo.ipynb rename to notebooks/Demos/monkey/monkey_demo.ipynb diff --git a/notebooks/monkey_demo_my_nnfabrik.ipynb b/notebooks/Demos/monkey/monkey_demo_my_nnfabrik.ipynb similarity index 100% rename from notebooks/monkey_demo_my_nnfabrik.ipynb rename to notebooks/Demos/monkey/monkey_demo_my_nnfabrik.ipynb diff --git a/notebooks/Demos/nnfabrik_insilico.ipynb b/notebooks/Demos/monkey/nnfabrik_insilico.ipynb similarity index 100% rename from notebooks/Demos/nnfabrik_insilico.ipynb rename to notebooks/Demos/monkey/nnfabrik_insilico.ipynb diff --git a/notebooks/nnvision_demo.ipynb b/notebooks/Demos/monkey/nnvision_demo.ipynb similarity index 100% rename from notebooks/nnvision_demo.ipynb rename to notebooks/Demos/monkey/nnvision_demo.ipynb diff --git a/notebooks/Extend_Data_Filetree.ipynb b/notebooks/Demos/mouse/Extend_Data_Filetree.ipynb similarity index 100% rename from notebooks/Extend_Data_Filetree.ipynb rename to notebooks/Demos/mouse/Extend_Data_Filetree.ipynb diff --git a/notebooks/FileTreeSet_training_demo.ipynb b/notebooks/Demos/mouse/FileTreeSet_training_demo.ipynb similarity index 100% rename from notebooks/FileTreeSet_training_demo.ipynb rename to notebooks/Demos/mouse/FileTreeSet_training_demo.ipynb diff --git a/notebooks/Mouse_Example.ipynb b/notebooks/Demos/mouse/Mouse_Example.ipynb similarity index 100% rename from notebooks/Mouse_Example.ipynb rename to notebooks/Demos/mouse/Mouse_Example.ipynb diff --git a/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb b/notebooks/Demos/mouse/Train Cortex Mapped Readout on FileTreeDataset.ipynb similarity index 99% rename from notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb rename to notebooks/Demos/mouse/Train Cortex Mapped Readout on FileTreeDataset.ipynb index f6ab2297..5eade75a 100644 --- a/notebooks/Train Cortex Mapped Readout on FileTreeDataset.ipynb +++ b/notebooks/Demos/mouse/Train Cortex Mapped Readout on FileTreeDataset.ipynb @@ -30,7 +30,11 @@ { "cell_type": "code", "execution_count": 19, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import datajoint as dj\n", @@ -299,4 +303,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/notebooks/Demos/mouse/__init__.py b/notebooks/Demos/mouse/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/notebooks/plots/Analyses/Best_MEI_textures.ipynb b/notebooks/plots/Analyses/Best_MEI_textures.ipynb deleted file mode 100644 index 1390a786..00000000 --- a/notebooks/plots/Analyses/Best_MEI_textures.ipynb +++ /dev/null @@ -1,1066 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Selecor Table Outline" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "fetch_download_path = '/data/fetched_from_attach'\n", - "\n", - "\n", - "import datajoint as dj\n", - "\n", - "\n", - "dj.config[\"enable_python_native_blobs\"] = True\n", - "dj.config['schema_name'] = \"nnfabrik_toy_V4\"\n", - "schema = dj.schema(\"nnfabrik_toy_V4\")\n", - "\n", - "from matplotlib import pyplot as plt\n", - "from torch import load\n", - "\n", - "from nnfabrik.main import *\n", - "import nnfabrik\n", - "from nnfabrik import main, builder\n", - "import os\n", - "from os import listdir\n", - "from os.path import isfile, join\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import pandas as pd\n", - "import numpy as np\n", - "from mei import mixins\n", - "import nnvision\n", - "from nnvision.tables.main import Recording\n", - "from nnvision.tables.from_nnfabrik import DataInfo, TrainedModel, TrainedHyperModel, TrainedTransferModel\n", - "from nnvision.tables.from_mei import MEI, MEIShared, MEISeed, Method, Ensemble, SharedReadoutTrainedEnsembleModel, MethodGroup\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "model = Ensemble().load_model(dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b'), include_dataloader=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:00<00:00, 6.46it/s]\n", - "100%|██████████| 2/2 [00:00<00:00, 6.55it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 6.20it/s]\n", - "100%|██████████| 2/2 [00:00<00:00, 6.14it/s]\n", - "100%|██████████| 7/7 [00:01<00:00, 6.39it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.29it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 7.32it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.57it/s]\n", - "100%|██████████| 8/8 [00:01<00:00, 6.26it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 6.07it/s]\n", - "100%|██████████| 4/4 [00:00<00:00, 6.48it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 6.29it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.37it/s]\n", - "100%|██████████| 12/12 [00:01<00:00, 6.31it/s]\n", - "100%|██████████| 13/13 [00:01<00:00, 6.57it/s]\n", - "100%|██████████| 13/13 [00:02<00:00, 6.11it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 6.70it/s]\n", - "100%|██████████| 7/7 [00:00<00:00, 7.27it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 5.98it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 6.15it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.52it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.79it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.22it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 6.35it/s]\n", - "100%|██████████| 10/10 [00:01<00:00, 5.98it/s]\n", - "100%|██████████| 18/18 [00:02<00:00, 6.27it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.31it/s]\n", - "100%|██████████| 10/10 [00:01<00:00, 6.25it/s]\n", - "100%|██████████| 5/5 [00:00<00:00, 5.96it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 6.14it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.33it/s]\n" - ] - } - ], - "source": [ - "mei_paths = []\n", - "texture_paths = []\n", - "\n", - "augmented_mei_paths = []\n", - "augmented_texture_paths = []\n", - "\n", - "unit_indices = []\n", - "data_keys = []\n", - "model_indices = []\n", - "\n", - "total_unit_index = 0\n", - "model_unit_index = 0\n", - "\n", - "for data_key, readout in model.members[0].readout.items():\n", - " for i in tqdm(range(readout.outdims - 32)):\n", - " unit_key = dict(unit_index=i, data_key=data_key, dataset_hash='ca53b3ae60291b7d55edd85b2a3b67ec')\n", - " unit_id = (Recording.Units & unit_key).fetch1(\"unit_id\")\n", - " mei_paths.append(((Recording.Units*MEI&dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b', method_hash='0797aa2784bdd350da556278c0f25fcf')) & unit_key).fetch1(\"mei\", download_path=fetch_download_path))\n", - " \n", - " unit_indices.append(i)\n", - " data_keys.append(data_key)\n", - " model_indices.append(model_unit_index)\n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='{data_key}, unit_id={unit_id}, unit_index={i}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='d41d8cd98f00b204e9800998ecf8427e',\n", - " method_hash='76394268b3e3d7668ac8420426725b35',\n", - " mei_seed=10)\n", - " texture_paths.append((MEITextures&texture_key).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='augmentation, 5x5, unit_index={total_unit_index}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='5819457fd546db900f0db3e5cd903475',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='708503aca7922d6e4b371656915a37fe',\n", - " method_hash='39dae9406b38011b6059e3b06ee8a1a7',\n", - " mei_seed=10)\n", - " augmented_texture_paths.append(((MEIPrototype&texture_key)).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='augmentation, 5x5, unit_index={total_unit_index}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='5819457fd546db900f0db3e5cd903475',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='708503aca7922d6e4b371656915a37fe',\n", - " method_hash='87a9feece9fd0dda00d3f927035d9fab',\n", - " mei_seed=10)\n", - " augmented_mei_paths.append(((MEIPrototype&texture_key)).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " total_unit_index += 1\n", - " model_unit_index += 1\n", - " \n", - " model_unit_index += 32\n", - " \n", - "\n", - "all_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in mei_paths])\n", - "texture_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in texture_paths])\n", - "augmented_texture_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in augmented_texture_paths])\n", - "augmented_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in augmented_mei_paths])\n", - "\n", - "tensor_all_MEIs=([torch.load(i).detach().cuda() for i in mei_paths])\n", - "tensor_texture_MEIs=([torch.load(i).detach().cuda() for i in texture_paths])\n", - "tensor_augmented_texture_MEIs=([torch.load(i).detach().cuda() for i in augmented_texture_paths])\n", - "tensor_augmented_MEIs=([torch.load(i).detach().cuda() for i in augmented_mei_paths])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "import scipy\n", - "from scipy import ndimage\n", - "from skimage import morphology\n", - "\n", - "\n", - "def generate_mask(mei, gaussian_sigma=1, zscore_thresh=.25, closing_iters=2, return_centroids=False):\n", - " \n", - " if type(mei) == torch.Tensor:\n", - " mei = mei.detach().cpu().numpy().squeeze()\n", - " is_tensor = True\n", - " \n", - " norm_mei = (mei - mei.mean()) / mei.std()\n", - " thresholded = np.abs(norm_mei) > zscore_thresh\n", - " \n", - " # Remove small holes in the thresholded image and connect any stranding pixels\n", - " closed = ndimage.binary_closing(thresholded, iterations=closing_iters)\n", - " # Remove any remaining small objects\n", - " labeled = morphology.label(closed, connectivity=2)\n", - " most_frequent = np.argmax(np.bincount(labeled.ravel())[1:]) + 1\n", - " oneobject = labeled == most_frequent\n", - " # Create convex hull just to close any remaining holes and so it doesn't look weird\n", - "\n", - " hull = morphology.convex_hull_image(oneobject)\n", - " # Smooth edges\n", - " smoothed = ndimage.gaussian_filter(hull.astype(np.float32), sigma=gaussian_sigma)\n", - " mask = smoothed # final mask\n", - " if not return_centroids:\n", - " return torch.tensor(mask)[None, None, ...].cuda() if is_tensor else mask\n", - " # Compute mask centroid\n", - " px_y, px_x = (coords.mean() + 0.5 for coords in np.nonzero(hull))\n", - " mask_y, mask_x = px_y - mask.shape[0] / 2, px_x - mask.shape[1] / 2\n", - " # Compute MEI std inside the mask\n", - " mei_mean = (mei * mask).sum() / mask.sum()\n", - " mei_std = np.sqrt((((mei - mei_mean) ** 2) * mask).sum() / mask.sum())\n", - "\n", - " return mask, px_x, px_y, mask_x, mask_y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Mask Done" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Build the Experiments" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1. Get model" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "dataloaders, model = Ensemble().load_model(dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b'))\n", - "model.eval();\n", - "model.cuda();" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2. Get Images" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:00<00:00, 5.81it/s]\n", - "100%|██████████| 2/2 [00:00<00:00, 6.57it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 6.74it/s]\n", - "100%|██████████| 2/2 [00:00<00:00, 6.65it/s]\n", - "100%|██████████| 7/7 [00:00<00:00, 7.16it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.23it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 6.52it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.29it/s]\n", - "100%|██████████| 8/8 [00:01<00:00, 6.22it/s]\n", - "100%|██████████| 3/3 [00:00<00:00, 6.00it/s]\n", - "100%|██████████| 4/4 [00:00<00:00, 6.03it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 6.85it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.02it/s]\n", - "100%|██████████| 12/12 [00:01<00:00, 6.68it/s]\n", - "100%|██████████| 13/13 [00:02<00:00, 6.18it/s]\n", - "100%|██████████| 13/13 [00:01<00:00, 6.57it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 6.19it/s]\n", - "100%|██████████| 7/7 [00:01<00:00, 6.23it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 6.79it/s]\n", - "100%|██████████| 9/9 [00:01<00:00, 6.53it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.53it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.47it/s]\n", - "100%|██████████| 6/6 [00:00<00:00, 6.88it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 7.35it/s]\n", - "100%|██████████| 10/10 [00:01<00:00, 6.60it/s]\n", - "100%|██████████| 18/18 [00:02<00:00, 7.32it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.61it/s]\n", - "100%|██████████| 10/10 [00:01<00:00, 6.20it/s]\n", - "100%|██████████| 5/5 [00:00<00:00, 6.05it/s]\n", - "100%|██████████| 11/11 [00:01<00:00, 5.96it/s]\n", - "100%|██████████| 14/14 [00:02<00:00, 6.20it/s]\n" - ] - } - ], - "source": [ - "mei_paths = []\n", - "texture_paths = []\n", - "\n", - "augmented_mei_paths = []\n", - "augmented_texture_paths = []\n", - "\n", - "unit_indices = []\n", - "unit_ids = []\n", - "data_keys = []\n", - "model_indices = []\n", - "\n", - "total_unit_index = 0\n", - "\n", - "for data_key, readout in model.members[0].readout.items():\n", - " for i in tqdm(range(readout.outdims-32)):\n", - " unit_key = dict(unit_index=i, data_key=data_key, dataset_hash='ca53b3ae60291b7d55edd85b2a3b67ec')\n", - " unit_id = (Recording.Units & unit_key).fetch1(\"unit_id\")\n", - " unit_ids.append(unit_id)\n", - " mei_paths.append(((Recording.Units*MEI&dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b', method_hash='0797aa2784bdd350da556278c0f25fcf')) & unit_key).fetch1(\"mei\", download_path=fetch_download_path))\n", - " \n", - " unit_indices.append(i)\n", - " data_keys.append(data_key)\n", - " model_indices.append(model_unit_index)\n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='{data_key}, unit_id={unit_id}, unit_index={i}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='c7cfccb056cebf84ed902b78937a391b',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='d41d8cd98f00b204e9800998ecf8427e',\n", - " method_hash='76394268b3e3d7668ac8420426725b35',\n", - " mei_seed=10)\n", - " texture_paths.append((MEITextures&texture_key).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='augmentation, 5x5, unit_index={total_unit_index}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='5819457fd546db900f0db3e5cd903475',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='708503aca7922d6e4b371656915a37fe',\n", - " method_hash='39dae9406b38011b6059e3b06ee8a1a7',\n", - " mei_seed=10)\n", - " augmented_texture_paths.append(((MEIPrototype&texture_key)).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " \n", - " unit_hash_single_texture = (MEITargetUnits & f\"unit_comment='augmentation, 5x5, unit_index={total_unit_index}'\").fetch1(\"unit_hash\")\n", - " texture_key = dict(ensemble_hash='5819457fd546db900f0db3e5cd903475',\n", - " unit_hash=unit_hash_single_texture, \n", - " target_hash='708503aca7922d6e4b371656915a37fe',\n", - " method_hash='87a9feece9fd0dda00d3f927035d9fab',\n", - " mei_seed=10)\n", - " augmented_mei_paths.append(((MEIPrototype&texture_key)).fetch1(\"mei\",download_path=fetch_download_path))\n", - " \n", - " total_unit_index += 1\n", - " model_unit_index += 1\n", - " \n", - "\n", - "all_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in mei_paths])\n", - "texture_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in texture_paths])\n", - "augmented_texture_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in augmented_texture_paths])\n", - "augmented_MEIs=([torch.load(i).detach().cpu().numpy().squeeze() for i in augmented_mei_paths])\n", - "\n", - "tensor_all_MEIs=[torch.load(i).detach().cuda() for i in mei_paths]\n", - "tensor_texture_MEIs=[torch.load(i).detach().cuda() for i in texture_paths]\n", - "tensor_augmented_texture_MEIs=[torch.load(i).detach().cuda() for i in augmented_texture_paths]\n", - "tensor_augmented_MEIs=[torch.load(i).detach().cuda() for i in augmented_mei_paths]\n", - "\n", - "unit_indices = np.array(unit_indices)\n", - "data_keys = np.array(data_keys)\n", - "unit_ids=np.array(unit_ids)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Building the full loop" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "def get_crops(mei, img_dim, edge_px):\n", - " crops = torch.ones(edge_px*edge_px,1,img_dim,img_dim).cuda()\n", - "\n", - " img_index = 0\n", - " for y in range(edge_px//2,int(3/2*edge_px)):\n", - " for x in range(edge_px//2,int(3/2*edge_px)):\n", - " crops[img_index] = mei[:, :, x:(x+img_dim), y:(y+img_dim)]\n", - " img_index+=1\n", - " return crops" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do - Other Cropped" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "other_texture_responses_cropped, other_augmented_texture_responses_cropped = [],[]\n", - "other_texture_responses_cropped_masked, other_augmented_texture_responses_cropped_masked = [],[]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Own" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 254/254 [04:25<00:00, 1.04s/it]\n" - ] - } - ], - "source": [ - "own_mei_responses, own_augmented_mei_responses, own_texture_responses, own_augmented_texture_responses = [],[],[],[]\n", - "own_augmented_mei_responses_masked, own_texture_responses_masked, own_augmented_texture_responses_masked = [],[],[]\n", - "own_texture_responses_cropped, own_augmented_texture_responses_cropped = [],[]\n", - "own_texture_responses_cropped_masked, own_augmented_texture_responses_cropped_masked = [],[]\n", - "\n", - "own_texture_responses_cropped_max, own_texture_responses_cropped_max_img = [],[]\n", - "own_augmented_texture_responses_cropped_max, own_augmented_texture_responses_cropped_max_img = [],[]\n", - "own_texture_responses_cropped_masked_max, own_texture_responses_cropped_masked_max_img = [],[]\n", - "own_augmented_texture_responses_cropped_masked_max, own_augmented_texture_responses_cropped_masked_max_img = [],[]\n", - "\n", - "masks = []\n", - "\n", - "with torch.no_grad():\n", - " for i in tqdm(range(len(tensor_all_MEIs))):\n", - "\n", - " mei = tensor_all_MEIs[i]\n", - " augmented_mei = tensor_augmented_MEIs[i]\n", - " mei_shape = mei.shape[2:]\n", - " \n", - " texture_mei = tensor_texture_MEIs[i]\n", - " texture_shape = texture_mei.shape[2:]\n", - " \n", - " augmented_texture_mei = tensor_augmented_texture_MEIs[i]\n", - " augmented_texture_shape = augmented_texture_mei.shape[2:]\n", - " \n", - " texture_crop = int((texture_shape[0]-mei_shape[0])/2)\n", - " aug_texture_crop = int((augmented_texture_shape[0]-mei_shape[0])/2)\n", - " \n", - " mask = generate_mask(mei, zscore_thresh=0.5, closing_iters=2)\n", - " masks.append(mask.detach().cpu().numpy().squeeze())\n", - " \n", - " own_mei_responses.append(model(mei, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_augmented_mei_responses.append(model(augmented_mei, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_texture_responses.append(model(texture_mei[:,:,texture_crop:-texture_crop, texture_crop:-texture_crop], data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_augmented_texture_responses.append(model(augmented_texture_mei[:,:,aug_texture_crop:-aug_texture_crop, aug_texture_crop:-aug_texture_crop], data_key=data_keys[i])[0][unit_indices[i]].item())\n", - "\n", - " own_augmented_mei_responses_masked.append(model(augmented_mei*mask, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_texture_responses_masked.append(model(texture_mei[:,:,texture_crop:-texture_crop, texture_crop:-texture_crop]*mask, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_augmented_texture_responses_masked.append(model(augmented_texture_mei[:,:,aug_texture_crop:-aug_texture_crop, aug_texture_crop:-aug_texture_crop]*mask, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " \n", - " # get crops\n", - " texture_crops = get_crops(texture_mei, img_dim=67, edge_px=texture_crop)\n", - " augmented_texture_crops = get_crops(augmented_texture_mei, img_dim=67, edge_px=aug_texture_crop)\n", - " \n", - " \n", - " # get all activations of texture crops\n", - " output = model(texture_crops, data_key=data_keys[i])[:,unit_indices[i]].detach().cpu().numpy()\n", - " own_texture_responses_cropped.append(output)\n", - " own_texture_responses_cropped_max.append(output.max())\n", - " own_texture_responses_cropped_max_img.append(texture_crops[np.argmax(output)])\n", - " \n", - " output = model(augmented_texture_crops, data_key=data_keys[i])[:,unit_indices[i]].detach().cpu().numpy()\n", - " own_augmented_texture_responses_cropped.append(output)\n", - " own_augmented_texture_responses_cropped_max.append(output.max())\n", - " own_augmented_texture_responses_cropped_max_img.append(augmented_texture_crops[np.argmax(output)])\n", - " \n", - " output = model(texture_crops * mask, data_key=data_keys[i])[:,unit_indices[i]].detach().cpu().numpy()\n", - " own_texture_responses_cropped_masked.append(output)\n", - " own_texture_responses_cropped_masked_max.append(output.max())\n", - " own_texture_responses_cropped_masked_max_img.append(texture_crops[np.argmax(output)])\n", - " \n", - " output = model(augmented_texture_crops * mask, data_key=data_keys[i])[:,unit_indices[i]].detach().cpu().numpy()\n", - " own_augmented_texture_responses_cropped_masked.append(output)\n", - " own_augmented_texture_responses_cropped_masked_max.append(output.max())\n", - " own_augmented_texture_responses_cropped_masked_max_img.append(augmented_texture_crops[np.argmax(output)])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Other " - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 31/31 [00:44<00:00, 1.45s/it]\n" - ] - } - ], - "source": [ - "other_mei_response, other_augmented_mei_responses, other_texture_responses, other_augmented_texture_responses = [],[],[],[]\n", - "other_augmented_mei_responses_masked, other_texture_responses_masked, other_augmented_texture_responses_masked = [],[],[]\n", - "\n", - "other_mei_img, other_augmented_mei_img,other_texture_img, other_augmented_texture_img = [],[],[],[]\n", - "other_augmented_mei_img_masked, other_texture_img_masked, other_augmented_texture_img_masked = [],[],[]\n", - "\n", - "_, idx = np.unique(data_keys, return_index=True)\n", - "original_sorted_keys = data_keys[np.sort(idx)]\n", - "\n", - "\n", - "with torch.no_grad():\n", - " for data_key in tqdm(original_sorted_keys):\n", - " tensor_masks= []\n", - "\n", - " mei = torch.stack(tensor_all_MEIs, dim=0)[:,0,...][[data_keys!=data_key]]\n", - " augmented_mei = torch.stack(tensor_augmented_MEIs, dim=0)[:,0,...][[data_keys!=data_key]]\n", - " texture_mei = torch.stack(tensor_texture_MEIs, dim=0)[:,0,...][[data_keys!=data_key]]\n", - " augmented_texture_mei = torch.stack(tensor_augmented_texture_MEIs, dim=0)[:,0,...][[data_keys!=data_key]]\n", - "\n", - " for single_mei in mei:\n", - " mask = generate_mask(single_mei[None, ...], zscore_thresh=0.5, closing_iters=2)\n", - " tensor_masks.append(mask)\n", - " tensor_masks = torch.stack(tensor_masks, dim=0)[:,0,...]\n", - "\n", - " outputs = model(mei, data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_mei_response.append(outputs[:,i].max().item())\n", - " other_mei_img.append(mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " outputs = model(augmented_mei, data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_augmented_mei_responses.append(outputs[:,i].max().item())\n", - " other_augmented_mei_img.append(augmented_mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " outputs = model(texture_mei[:,:,texture_crop:-texture_crop, texture_crop:-texture_crop], data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_texture_responses.append(outputs[:,i].max().item())\n", - " other_texture_img.append(texture_mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " outputs = model(augmented_texture_mei[:,:,aug_texture_crop:-aug_texture_crop, aug_texture_crop:-aug_texture_crop], data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_augmented_texture_responses.append(outputs[:,i].max().item())\n", - " other_augmented_texture_img.append(augmented_texture_mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " \n", - " # augmented MEI masked\n", - " outputs = model(augmented_mei*tensor_masks, data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_augmented_mei_responses_masked.append(outputs[:,i].max().item())\n", - " other_augmented_mei_img_masked.append(mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " # texture masked\n", - " outputs = model(texture_mei[:,:,texture_crop:-texture_crop, texture_crop:-texture_crop] * tensor_masks, data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_texture_responses_masked.append(outputs[:,i].max().item())\n", - " other_texture_img_masked.append(mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " # augmented texture masked\n", - " outputs = model(augmented_texture_mei[:,:,aug_texture_crop:-aug_texture_crop, aug_texture_crop:-aug_texture_crop] * tensor_masks, data_key=data_key)\n", - " for i in range(sum(data_keys==data_key)):\n", - " other_augmented_texture_responses_masked.append(outputs[:,i].max().item())\n", - " other_augmented_texture_img_masked.append(mei[torch.argmax(outputs[:,i])].detach().cpu().numpy().squeeze())\n", - " \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Self Analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.set_context(context='talk', font_scale=0.8)\n", - "\n", - "fig, axs = plt.subplots(1,5, figsize=(30,6))\n", - "\n", - "titles = [\"own Augmented MEI\", \"own Texture\", \"own 16x16 crops - Texture\", \"own augmented Texture\", \"own 24v24 crops - augmented Texture\"]\n", - "var_list = [own_augmented_mei_responses, own_texture_responses, own_texture_responses_cropped_max, own_augmented_texture_responses, own_augmented_texture_responses_cropped_max]\n", - "var_list_masked = [own_augmented_mei_responses_masked, own_texture_responses_masked, own_texture_responses_cropped_masked_max, own_augmented_texture_responses_masked, own_augmented_texture_responses_cropped_masked_max]\n", - "\n", - "for i, ax in enumerate(axs.ravel()):\n", - "\n", - " activation = np.sum(var_list[i]) / np.sum(own_mei_responses)\n", - " ax.scatter(own_mei_responses, var_list[i], edgecolors='w', linewidths=.5, color='k', label='unmasked: '+ str(np.round(activation,3)))\n", - " activation = np.sum(var_list_masked[i]) / np.sum(own_mei_responses)\n", - " ax.scatter(own_mei_responses, var_list_masked[i],edgecolors='w', linewidths=.5, color='g', label='masked: '+ str(np.round(activation,3)))\n", - " ax.set_aspect(\"equal\")\n", - " ax.set_xlim([0,25])\n", - " ax.set_ylim([0,25])\n", - "\n", - " ax.set_xlabel(\"own MEI activation\")\n", - " ax.set_ylabel(titles[i])\n", - "\n", - " ax.plot([0,25], [0,25], 'r--')\n", - " ax.legend();\n", - "\n", - " ax.set_title(titles[i])\n", - "sns.despine(trim=True, offset=10)\n", - "\n", - "# plt.savefig(\"Own_Textures_Comparison.png\", dpi=100,bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Self vs other" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.set_context(context='talk', font_scale=0.8)\n", - "\n", - "fig, axs = plt.subplots(1,4, figsize=(30,6))\n", - "\n", - "titles = [\"second-best MEI\", \"second-best augmented MEI\", \"second-best Texture\", \"second-best augmented Texture\"]\n", - "var_list = [other_mei_response, other_augmented_mei_responses, other_texture_responses, other_augmented_texture_responses]\n", - "var_list_masked = [0, other_augmented_mei_responses_masked, other_texture_responses_masked, other_augmented_texture_responses_masked]\n", - "\n", - "for i, ax in enumerate(axs.ravel()):\n", - "\n", - " activation = np.sum(var_list[i]) / np.sum(own_mei_responses)\n", - " ax.scatter(own_mei_responses, var_list[i], edgecolors='w', linewidths=.5, color='k', label='unmasked: '+ str(np.round(activation,3)))\n", - " if i > 0:\n", - " activation = np.sum(var_list_masked[i]) / np.sum(own_mei_responses)\n", - " ax.scatter(own_mei_responses, var_list_masked[i],edgecolors='w', linewidths=.5, color='g', label='masked: '+ str(np.round(activation,3)))\n", - " ax.set_aspect(\"equal\")\n", - " ax.set_xlim([0,25])\n", - " ax.set_ylim([0,25])\n", - "\n", - " ax.set_xlabel(\"own MEI activation\")\n", - " ax.set_ylabel(titles[i])\n", - "\n", - " ax.plot([0,25], [0,25], 'r--')\n", - " ax.legend();\n", - "\n", - " ax.set_title(titles[i])\n", - "sns.despine(trim=True, offset=10)\n", - "\n", - "#plt.savefig(\"Second_Best_Textures.png\", dpi=100,bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Detailed Plot for all Neurons" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for plots in range(21):\n", - "\n", - "\n", - " fig, axs = plt.subplots(12,12, figsize=(30, 35))\n", - "\n", - " offset = 12*plots\n", - "\n", - " for i in range(12):\n", - " for j in range(12):\n", - "\n", - " if j == 0:\n", - " axs[i,j].imshow(all_MEIs[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"MEI \\n\" + \"Mei Act = \" +str(round(own_mei_responses[i+offset])))\n", - " else:\n", - " axs[i,j].set_title(\"Mei Act = \" +str(round(own_mei_responses[i+offset],1)))\n", - "\n", - " if j == 1:\n", - " axs[i,j].imshow(augmented_MEIs[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Augmented MEI \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_augmented_mei_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_augmented_mei_responses[i+offset], 1)))\n", - "\n", - "\n", - " if j == 2:\n", - " axs[i,j].imshow(texture_MEIs[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " rect = patches.Rectangle((16,16),67,67 ,linewidth=1,edgecolor='k',facecolor='none')\n", - " axs[i,j].add_patch(rect)\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Texture \\n\" + \"Mei Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_texture_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_texture_responses[i+offset], 1)))\n", - "\n", - " if j == 3:\n", - " axs[i,j].imshow(augmented_texture_MEIs[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " rect = patches.Rectangle((24,24),67,67 ,linewidth=1,edgecolor='k',facecolor='none')\n", - " axs[i,j].add_patch(rect)\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Aug Texture \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]/ own_augmented_texture_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_augmented_texture_responses[i+offset], 1)))\n", - "\n", - " if j == 4:\n", - " axs[i,j].imshow(own_texture_responses_cropped_max_img[i+offset].detach().cpu().numpy().squeeze(), cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Tex Best Crop \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_texture_responses_cropped_max[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_texture_responses_cropped_max[i+offset], 1)))\n", - "\n", - " if j == 5:\n", - " axs[i,j].imshow(own_texture_responses_cropped[i+offset].reshape(16,16).T, cmap=\"hot\")\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Tex Activation\")\n", - "\n", - " if j == 6:\n", - " axs[i,j].imshow(own_augmented_texture_responses_cropped_max_img[i+offset].detach().cpu().numpy().squeeze(), cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Aug. Tex Best Crop \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_augmented_texture_responses_cropped_max[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* own_augmented_texture_responses_cropped_max[i+offset], 1)))\n", - "\n", - " if j == 7:\n", - " axs[i,j].imshow(own_augmented_texture_responses_cropped[i+offset].reshape(24,24).T, cmap=\"hot\")\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"Aug Tex Activation\")\n", - "\n", - " if j == 8:\n", - " axs[i,j].imshow(other_mei_img[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"2nd Best MEI \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_mei_response[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_mei_response[i+offset], 1)))\n", - "\n", - " if j == 9:\n", - " axs[i,j].imshow(other_augmented_mei_img[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"2nd Best Aug MEI \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_augmented_mei_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_augmented_mei_responses[i+offset], 1)))\n", - "\n", - " if j == 10:\n", - " axs[i,j].imshow(other_texture_img[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"2nd Best Texture \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_texture_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_texture_responses[i+offset], 1)))\n", - "\n", - " if j == 11:\n", - " axs[i,j].imshow(other_augmented_texture_img[i+offset], cmap=\"gray\", vmin=-1.7, vmax=2.2)\n", - " axs[i,j].axis(\"off\")\n", - " if i == 0:\n", - " axs[i,j].set_title(\"2nd Best Aug Texture \\n\" + \"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_augmented_texture_responses[i+offset], 1)))\n", - " else:\n", - " axs[i,j].set_title(\"% Act = \" +str(round(1/own_mei_responses[i+offset]*100* other_augmented_texture_responses[i+offset], 1)))\n", - "\n", - " plt.savefig(f\"MEI_2nd_best_comparison_{plots}.png\", dpi=100, bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create the Mask Cutoff Plot" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 254/254 [00:04<00:00, 54.03it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 56.02it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.09it/s]\n", - "100%|██████████| 254/254 [00:05<00:00, 49.77it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 52.04it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.23it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.26it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.11it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.28it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.17it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 53.27it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 52.38it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 54.62it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 55.23it/s]\n", - "100%|██████████| 254/254 [00:04<00:00, 55.28it/s]\n" - ] - } - ], - "source": [ - "own_mei_responses, masked_mei, own_texture_responses, own_augmented_texture_responses = [],[],[],[]\n", - "own_augmented_mei_responses_masked, own_texture_responses_masked, own_augmented_texture_responses_masked = [],[],[]\n", - "own_texture_responses_cropped, own_augmented_texture_responses_cropped = [],[]\n", - "own_texture_responses_cropped_masked, own_augmented_texture_responses_cropped_masked = [],[]\n", - "\n", - "other_augmented_mei_responses, other_texture_responses, other_augmented_texture_responses = [],[],[]\n", - "other_augmented_mei_responses_masked, other_texture_responses_masked, other_augmented_texture_responses_masked = [],[],[]\n", - "other_texture_responses_cropped, other_augmented_texture_responses_cropped = [],[]\n", - "other_texture_responses_cropped_masked, other_augmented_texture_responses_cropped_masked = [],[]\n", - "masks = []\n", - " \n", - "own_r = []\n", - "mask_r=[]\n", - "for gif_counter, z_thresh in enumerate(np.round(np.linspace(0.1,1.5, 15),1)):\n", - " masks = []\n", - " own_mei_responses, masked_mei = [],[]\n", - " with torch.no_grad():\n", - " for i in tqdm(range(len(tensor_all_MEIs))):\n", - "\n", - " mei = tensor_all_MEIs[i]\n", - " augmented_mei = tensor_augmented_MEIs[i]\n", - " mei_shape = mei.shape[2:]\n", - "\n", - " texture_mei = tensor_texture_MEIs[i]\n", - " texture_shape = texture_mei.shape[2:]\n", - "\n", - " augmented_texture_mei = tensor_augmented_texture_MEIs[i]\n", - " augmented_texture_shape = augmented_texture_mei.shape[2:]\n", - "\n", - " texture_crop = int((texture_shape[0]-mei_shape[0])/2)\n", - " aug_texture_crop = int((augmented_texture_shape[0]-mei_shape[0])/2)\n", - "\n", - " mask = generate_mask(mei, zscore_thresh=z_thresh, closing_iters=2)\n", - " masks.append(mask.detach().cpu().numpy().squeeze())\n", - "\n", - " own_mei_responses.append(model(mei, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " masked_mei.append(model(mei*mask, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_r.append(np.mean(own_mei_responses))\n", - " mask_r.append(np.mean(masked_mei))\n", - "own_r = np.array(own_r)\n", - "mask_r = np.array(mask_r)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No handles with labels found to put in legend.\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1,1, figsize=(6,6))\n", - "\n", - "plt.plot(np.round(np.linspace(0.1,1.5, 15),1),mask_r/own_r)\n", - "\n", - "ax.set_xlabel(\"mask z-score cutoff\")\n", - "ax.set_ylabel(\"% activation\")\n", - "sns.despine(trim=True, offset=10)\n", - "\n", - "plt.savefig(\"mask_zscore_cutoff_drop.png\", dpi=100, bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create the Mask Gif" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "own_mei_responses, own_augmented_mei_responses, own_texture_responses, own_augmented_texture_responses = [],[],[],[]\n", - "own_augmented_mei_responses_masked, own_texture_responses_masked, own_augmented_texture_responses_masked = [],[],[]\n", - "own_texture_responses_cropped, own_augmented_texture_responses_cropped = [],[]\n", - "own_texture_responses_cropped_masked, own_augmented_texture_responses_cropped_masked = [],[]\n", - "\n", - "other_augmented_mei_responses, other_texture_responses, other_augmented_texture_responses = [],[],[]\n", - "other_augmented_mei_responses_masked, other_texture_responses_masked, other_augmented_texture_responses_masked = [],[],[]\n", - "other_texture_responses_cropped, other_augmented_texture_responses_cropped = [],[]\n", - "other_texture_responses_cropped_masked, other_augmented_texture_responses_cropped_masked = [],[]\n", - "masks = []\n", - " \n", - "\n", - "for gif_counter, z_thresh in enumerate(np.round(np.linspace(0.1,1.5, 15),1)):\n", - " masks = []\n", - " with torch.no_grad():\n", - " for i in tqdm(range(len(tensor_all_MEIs))):\n", - "\n", - " mei = tensor_all_MEIs[i]\n", - " augmented_mei = tensor_augmented_MEIs[i]\n", - " mei_shape = mei.shape[2:]\n", - "\n", - " texture_mei = tensor_texture_MEIs[i]\n", - " texture_shape = texture_mei.shape[2:]\n", - "\n", - " augmented_texture_mei = tensor_augmented_texture_MEIs[i]\n", - " augmented_texture_shape = augmented_texture_mei.shape[2:]\n", - "\n", - " texture_crop = int((texture_shape[0]-mei_shape[0])/2)\n", - " aug_texture_crop = int((augmented_texture_shape[0]-mei_shape[0])/2)\n", - "\n", - " mask = generate_mask(mei, zscore_thresh=z_thresh, closing_iters=2)\n", - " masks.append(mask.detach().cpu().numpy().squeeze())\n", - "\n", - " if yo:\n", - " own_mei_responses.append(model(mei, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_augmented_mei_responses.append(model(augmented_mei, data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_texture_responses.append(model(texture_mei[:,:,texture_crop:-texture_crop, texture_crop:-texture_crop], data_key=data_keys[i])[0][unit_indices[i]].item())\n", - " own_augmented_texture_responses.append(model(augmented_texture_mei[:,:,aug_texture_crop:-aug_texture_crop, aug_texture_crop:-aug_texture_crop], data_key=data_keys[i])[0][unit_indices[i]].item())\n", - "\n", - "\n", - " #mei_shape = [16:-16, 16:-16]\n", - "\n", - " neurons_own_response = 0\n", - "\n", - " fig, axs = plt.subplots(13,20, figsize=(30,22))\n", - " for j, ax in enumerate(axs.ravel()):\n", - " if j >= len(masks):\n", - " ax.axis(\"off\")\n", - " continue\n", - " ax.imshow(all_MEIs[j], cmap=\"gray\")\n", - " ax.contour(masks[j])\n", - " ax.axis(\"off\")\n", - " ax.set_title(str(z_thresh))\n", - " plt.savefig(f\"mask_gif_\" + str(gif_counter).zfill(2) +\".png\", dpi=75, bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "code", - "execution_count": 873, - "metadata": {}, - "outputs": [], - "source": [ - "import glob\n", - "from PIL import Image\n", - "\n", - "fp_in = \"/notebooks/notebooks/monkey/texture/mask_gif_*.png\"\n", - "fp_out = \"/notebooks/notebooks/monkey/texture/mei_mask_selection.gif\"\n", - "\n", - "img, *imgs = [Image.open(f) for f in sorted(glob.glob(fp_in))]\n", - "img.save(fp=fp_out, \n", - " format='GIF',\n", - " append_images=imgs,\n", - " save_all=True, \n", - " duration=500, \n", - " loop=0)" - ] - } - ], - "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/notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.ipynb b/notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.ipynb deleted file mode 100644 index ba019306..00000000 --- a/notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.ipynb +++ /dev/null @@ -1,161 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import datajoint as dj\n", - "dj.config[\"enable_python_native_blobs\"] = True\n", - "dj.config['schema_name'] = \"nnfabrik_toy_V4\"\n", - "schema = dj.schema(\"nnfabrik_toy_V4\")\n", - "\n", - "import os\n", - "from os import listdir\n", - "from os.path import isfile, join\n", - "\n", - "\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pickle \n", - "import time\n", - "from torch import load\n", - "\n", - "import nnfabrik\n", - "from nnfabrik import main, builder\n", - "from nnfabrik.main import *\n", - "\n", - "import nnvision\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "from nnvision.utility.measures import get_explainable_var\n", - "n_repeats = np.hstack([np.arange(2,10), np.arange(10,20,2), np.arange(20,36,4)])\n", - "n_iters = 10\n", - "\n", - "v4_hash= '293317b0600244345fe605961ef9f170'\n", - "v1_hash = '839b51124b143e456cfcf1d78954ea7d'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "key = dict(dataset_hash=v4_hash)\n", - "dataloaders = (Dataset() & key).get_dataloader(seed=1000)\n", - "\n", - "rep_array, score_array=[],[]\n", - "for i in range(n_iters):\n", - " for reps in n_repeats:\n", - " score = get_explainable_var(dataloaders[\"test\"], per_neuron=False, repeat_limit=reps)\n", - " rep_array.append(reps)\n", - " score_array.append(score)\n", - "\n", - "v4_reps = rep_array\n", - "v4_scores = score_array\n", - "\n", - "\n", - "key = dict(dataset_hash=v1_hash)\n", - "dataloaders = (Dataset() & key).get_dataloader(seed=1000)\n", - "rep_array, score_array=[],[]\n", - "for i in range(n_iters):\n", - " for reps in n_repeats:\n", - " score = get_explainable_var(dataloaders[\"test\"], per_neuron=False, repeat_limit=reps)\n", - " rep_array.append(reps)\n", - " score_array.append(score)\n", - "\n", - "v1_reps = rep_array\n", - "v1_scores = score_array\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.DataFrame({'repeats': np.hstack([v1_reps, v4_reps]), \n", - " 'explainable variance': np.hstack([v1_scores, v4_scores]),\n", - " 'dataset': ['v1']*len(v1_reps) + ['v4']*len(v4_reps)})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plt.subplots(1,1, figsize=(6,6))\n", - "sns.set_context('talk', font_scale=0.8)\n", - "\n", - "flatui = [\"#9b59b6\", \"#3498db\", \"#95a5a6\", \"#e74c3c\", \"#34495e\", \"#2ecc71\"]\n", - "plt.grid(\"on\", ls='--')\n", - "sns.lineplot(x=\"repeats\", y=\"explainable variance\", hue=\"dataset\",data=df, ci=\"sd\", palette=flatui[-2:])\n", - "plt.ylim([0.29, 0.34])\n", - "sns.despine(trim=True, offset=2)\n", - "plt.title(\"Explainable Variance across repeats\")\n", - "plt.savefig(\"Monkey_V2_explainable_variance.pdf\", dpi=100, bbox_inches=\"tight\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "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/notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.pdf b/notebooks/plots/descriptive_statistics/Monkey_V1_V4_explainable_variance.pdf deleted file mode 100644 index 8b37dcac91afb47a5f883ac04790dded9ec5282a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12259 zcmb_?2{@I{_qZk0O(|=lJ}*Lx+}(Ap*~z}Eh>J@%JJ-G>g%l-gWC>Z@DIq0W+0%lg zRF;%|%hKjI@0Chq) zJE^)jQz7hPTaQGglHHvlJp712>bbkv7?P>bA;3pj70@U9P$8s-6X2=%vsU_9Yd{td z((nk$mf~y=Ni23Z)3rWIwxL1<8u8!apiuy@Gynx>XBVmmU;+9o0a3`#;EA|MK+WC7 z(-ne;sbmNtmC0Td8?u2KU=5y(+)2(Jt|WJ|vyJc4$QSVeBcwLjmO@f=@d0#UW;irT zoIsF7WAG3Tg%+2@;3Ys4aMXhdP?z*)K=yF)bhiNtg*65gu&7X2$A4%O7H&y;Rf;1} z7=%=H1R7N)+ql?*3D6=t+f$D~Xn39s;EoGV^%Ey~99 zJ74G{Zg9QtYGD2P?j@sk^D_gz$z&t-9|5AR*b|S(1){dSP!RA$SXijras~4rloz|* zeKqKNu)JkQ#f^%0W8QnNxr`6kP568%Su?4F=TMXBo;g<;+sM!H!}m;Ob+3G4e@A~0 zSJms@JA}rV$@h26!sF`>oAcl7+RkBYUm85}CajI^o4@S3J?!R(Lu0dUcaOAJTuX01 zV`@I-I$V3fx*=btuV!oJ-EtpMiht(kQRdi%n=xm$37>mVHgn@aU{OHV!+RIW^*v27 zJ{C!x5uquJ>J(Ij7m0~`=RViwF*3{e+N3PtR0wyvl zG8dTWoyB7cjAhhV*fGo`vBRGuFs?ICKLwefiOm8YNn$piza_|8VP`ZD{4ue68&CPx zTvDfV-7mhau+laCwkk{b*%>22K8;I-S|%aeaZ2m12wGh`nV6C~T%_B_I%bl+p(LKX zHX*(0>s+1LHF4wgjYb#8ou2Iqd`I6?-)kEy#ho6nderEq-Qg2jTDuVfb9xhLz5$|q z!WoooPImSU$vN>%X_y2{5n-$APf@Y(u(q4O4^p{_k3&q+`^Mdw#3amk%ejj^91qw2_i|tv9o#>)pLKF88iHnMF2#By_*3IHw!e z&5s*gBYQAPl6umprzbM5@onff$KaXXJb@Rd&q=v^&^-~&4Rso(>ZfOfyP85N4Kv^B z&JeDg{V&DD&HUnA=ZOVI`Nuc6$?qNX_!jr|=w%`K>E1b#IiKM3x+nB9>FM0X6VFuw z!~WYiY@Hw^|E+hfvcG{6cRrobM^1jPV{h)6FRb$YI*D#%sc|9s==ARoW+q6p(~d!B zNzy?FUkuFYn^UWA$!q%97ERTCU^}UsRn)IHd#}ee;r^Y`!2hmnum~CcG1WEF_Epz( zq2$dq%j=`vmVss6shUzZj$Ieyl+Qjt9yL1B<-3b{fcg2Urfetg8ROlx$`|FICt38f z_ukiPH&ZZtsnyi2!FblDto2A2=Z!+2bDu?I=BV8&mgQmf9ZKRCGEI{L9`>*mh^#BJ zacB`Njz!H!?z-eKDe<64c(cBB2)if;NA8YZv7+Ak){@Ypj2kynNSxKr9rF;G1975! zIRW_7=i2d23um^c6@S^@LBC!BEx?A^*xz!$mQ0@iB$C^5Tf;=EE&rHl$*h2hO*SEv^M-0P{-XNPxfrL%=enr|;z9p8*#%7H zwbJQT$EXo5a@D*OuZ{JzESyFkRF5Tvp*EeJ6=mkL3Gw|(wnFulv}*hLO&6Rgck%ym zJ3TFJzpg)N!+h`o4?mSWA=w8$jwMP(_mjRt$6F1m4RCRHi{}kHCVrHS`3$vvep4|z z*6~Tvbz-;U#rheK?qRcm@49|g39ZVPTk3_LUu(2x(92g(b459r>0X=&c}03GR>6{% zX+C)CQitZb#7x%khb(%Uxv#qA1FjTY-naLfELFCN#Kv83#B-IUlNG7C5V8GLuKWFI ztH!ThHCV`hsY3pd){kY~?R+EXm9Qf@SZfNk*#X0&D<#L{rU;JKI40PEC zbI$nI_L&vj?6wGeQ1&)Z?o{rM;;{hx(cr*mbJp`rIs-L)a&3qOJNim zj%!xq`3b~jUSGTU-iC(|>zdZIT`~;s7Uc8`ZXV;~6I8U3|D+>TxsmI2&&@4Iyh{#F zWb0oD986-5(esd1Hp2=_oxE)Mr4dzq;bmR%*j@nt;b&4C!WY;28B1awr*;`NT3Z+I2==Me73Ro56p?icPv5_{mhSg{nbzF&@QyN)qjA@hj6F54RptwmqRI-TY744S zsfVWXQqF{F$0iT#*5tjrKCSvr#6Ut|4I2TM$Kn~KS+(I!+mQo^W>?Pz>HBJ(-gp_F zi$;Slc+T(9I10w7(}nW~YF;KT4IGz0dIJzOzN<*Cr1u&TPE9wXjOzsK!8% zsLV@GKV5NWp5{$#wxvdMI{L#St=I>{``5{`7r!?f4U|s4^=a!x$>E?e)%J$S>qi8F z>P$t4gsom1im0&L>J*zfpJ_`Q&Dfda5$3@Q4R)RmGx%U_dgU0aw2K(BQ>-qoX+1_Y zS36D8r!FWedD=IAz~?)?8}>XwMVPHYUZuS$4mYLw`G zA8FC49_Srj5M*cTU!>j~9Um|CSrI4lQed;J5ST<%QIxjJ1u$;-{pNc4T^y+>TBp2neQo+Tb70ozW5WdffZt zDr!i7N6a&OmN#x9S=tE}jKoskf}1A0iKpZaKYes^kXmruro5wgnuGGLbjI>Mi(KHs zxh-ExyX7B^nhXA`HO!x9k^g0`80_-ZgV)z^2Ig8m#5HxCu1CD$v4ZZ%!i{au)>&B{ z(M)OH%*VIcC!+F+Lf@l9?UBiI7wau1?#Xa%Uw1b|RDaFkF#pbV;x1bfze_d+j2}Ko zjNPh>fp|Kn$Cc}>68C+4IK1@*=^{n+OW4ULXVvk12XrhoTQ#q2+Ns+al)HZa?Q4Ti zMvBC5k2vT`c8=tW#_K|9hYA@IqfE89ZFr}Z`^9Ug6$*+%(@sui25c;x&l6y`$V@pd z%FL3rPx|ISae9Pl=p|3j^x~+Dt-H4AE=b_;8iIWs!YQ54N)FBaNb~>xjWNf_FntAe z{dxBMpX$OaH!{4gbRnYv>ku(iJeoJs$?8c_k`Z#&CEd1g1N#s4$!TRZk;5PA)?V$L zDCXup#XHAsIB`REr26EbY)Saq{vO2(q#Y^vp^}Tay|on<{n+-(dmA2DC-AH(M#X-P zuT5(7sx;dw>ZVi3XVanVXk#(-iL-sP)=ox&)De_$9Y5Euz{0FZqLfZw#DH}{t$4*4 zDX=mJoms_i%B0(BtCt`{lck-nyk0tTzb@06=c^}@PzhYYo73gDzu!u zyf5W5@1`W5uveU znkXoI64h}$`;KGL^Yg<3Q71JughdjA40kWw-gRjA$5$#GH`V)&$7HtPgG=IumCvdcA+ta?xY~!yf z-@DHzObXuV%4qv!Dy*Lr)s`DwBC`;gKJkO`?4<*=n~LQg7z1BPtWJB&Elpeho|7`r z-dj%dcXUGzzG>?XEM{Dk>eohBK^e$hxx(Btk2G1|vm9c3(0ATg>DYF8^e|RTw!ZI$ z{D;zdBhCk01s5;q@mRnAeq>EKHx((kr-9||IWnt9%j~Ww<3KxyGcx!WtUFT}X){U4D3Z;r5M;~F1o=0@bYdU$No2{}UZ^cK~x^K@z#4sJS z>iEQ`eCm|W_wLp)4MAJGhPHG{g{vmG0gK~n1Zcqv)yz`Oev(#d<~zScjP`o5lPr}^#`tPj54S&jaP%l9?yC=$iaHOdL;{kWQLq>*WruYkB1J zQNkI|-nYgx*yM8WkvN0E(ppM9b>fJG$DZ}qIJVhs^oz^ly|hV+t9vA~&pl_fWnRto zv*l;CTcat>H4kn3H=eZnylXVz;x>JYH@3%~**Ld59OIfPxOw|(cK^w)77Og9HKY0b zBj1_wJ)};qFw#{Ag}@*Gd0~dvzvotqVjaRW@riKuV@E~;yP{^?Qrd&b;L#)F>bS>Jx$lP?lP(~4v>~8Wnpr6 zD{9T%%Es&WO-~;~VV+Cqx;o{bxF@O-+#n zn|a$c!dVQ~JacqrN8wZo2T$<5G<}Sh*H!DRtXHTwT{$NqnS|8vwPecJbdKl8#wVS1 zw_=oba83r^d3Z|5F?e%^?ugJPa7n8&JDOx5Ct`ehj80X6Kd`_QQ_gd~^JrM}0m+(xvVIm$R3xhRUa2F)ev)am+m$>P3!RT@P21o3E|x;$k?00v#p4U zz=#i=vv1lGij;7PM~Fe|vAYZSwmsLBNOs-LQFiHdHTKH}Cn}>!`1V_epw`P)9mSCQ zW40}y$3Ht-;GOI^3bV-t9L}IHE@74Ibu*=*4C8D=oB_JRV{UKW#AmuX;d? zx4JD!a=DqRM1m6@YOS(=j@6nV5xexA@kPh@p#861b<6xqq}VZr-K4PaHEFD3VTKdT zNm*9-5>$ z)8_9qb_me7D76_6{OGz>Z8WkwY|Alqwoiq|+lLITJtKxEv$Yc&Fuq)Q{kmNX`m7Aj z3$1kux9>)#T7O_~udUi4(~lG46YUWD@0_$QpIzvqnyB7XabBx*ZhHKo_~zq8Cn>_d zvgoaM3yQjJ^;iW56`NUN#Zz*hCY~au1vw#L)Lu=KES+hYo;X2b&>Er8|WT=+#s?7PX#DcfMJ2ivUS!H1#tQ4$Z>}A@ z_4ujxLO##@{@X5ed&6%C8y5U0Dwy-Sc2`?tI(|`_UJCbkJ9_ z?q(!~zZfdXD=6`_i+@gOY^Xgpb;J}KD_eyh6dl+8IF~MSJOAUMOE=cX1@5~enW~|O z4!mJ~JS)ZPm|)75cXGUHNxOvHtep|Vv%GY64@^rQ^)kJoC-|-~%GCxKSS)6lP3|=y zp51|FZTyZ1vZ5QBoJiZQ_2TOSRl}Hxslc&Orq8`vSvW{6x=Y`or$g25Qq}m4D@~ze z>RokGryS~3%fU1H@P;Q$FQKljP|$p_f#^VQY4o|hqXvg$ZB zUna~YpH6=EqH+9f;wHXmFKZh+{v#xV@9KzOwQ5*qtg zta7e#1GrsK8Z&y&KFKSWAKsSs^2d!KRI-BNoPwbA1ZwTosY!{}+VQ8E)r21sZC7mK z#r`YvGcaNM6dhhZ$)!g@>DPoF(AuU%YPrx*mw>s;_r6&B#8t<5qiZL;WSH5CbIDiM z2IV`E2E`^=tBenqJl-H5t$EG+zVU-&iiW7f6~?mKxC@J29(m#oh}YljV;u@aSU|yE z%_##+`9Y&^!{RIvO1Di;C!ghxr_7TDjQ7ThSBz*lMet3|)*~V~VoZf!WwV~wo0kbS zs<3Y?f6$(?8PbeL#Ky)v7GD2@HL+Wqf565;{+y7vte=%} z$>h+>_iT2*Zg!X7hD&`zncFL_F{LTrx~-7ig@n@x3zG=$AccubYS#j1&5X>Trz89t zu8~oC=YzeDzfxx<7IELpLw-3BcVQiM1L?dHIbSGLBhp&x%Z8cA@upnqGXGk!PZlbc5e2^jU3kU*Nvo z9DY_`7CPp9e|%%)FAg?ZVQN+zC}MESr)IA{F@{lLZQ}r!pQ6X}v0IJjXBR#p8t6}i zDM3B;rFm)L( zc7k_^QQihY@N@Igdek}M$%|j(-{GKZr-#|Y<5pk8Wa#;_E~#2KCvyFW`I8NGrJLKy zTP|OWe-wFANL#=_J!4QLAFB|(ChLlRRuq42(5FVBRFbjKQP!{Knq3_p94%XM(%e^M zh}mkUDUJ2D>-VsHFK>RRVzl*&%qDi%iY}$^DZ_n)?q{V%wbOHlJqpWFTxJs=?(jux z-wT`OT`H5RL>0uIdqI*iC| zY>Anb2RD?32)TOZe|suqQMyYd(WWKjy<35$I$BjWPpG&1v2LlQD>r-Kzw+Q#9Z@ac zknq~2uslOaA)A}BUJl1<_7A^h9xhRk3WVbL9Qx=(-lw_<%;g|?PkOG^-F;73$}uCX z2oV$U-c-WJ`10@<+@ema4LVp;E1vp3Bu6}6@p!H9cv66;|HlWqygo;H-M!XqR;ssJ zceIRK+w8VXdbAFG&q7f3=-$4Jn5l*|zIncsk#XrF=l7yVy#$}Sb75W-;T~^U%b~Je z##bfBwWp}vyA8+w!fw4z0{wLz`N)lQR)U8Q1P@OOAzhq7<^tcmo2ESAzde#s6ekf>7JJ*e>bfD(}K$Q2i}N%o>q7&NpO zCxL~~1R@SXW3X5_kpxCjCVSYpQ(UPo?hu-mPy@&Sur`V6PN8L@h@()jy@9`9Eznhq z^pg_?59HS&If23d)-nQV=xI%*CHBDCDA=W3m&MsIrPxxB0QD~>00F_5zF++rf+~2} zz)3Dd3=vKaa#bf&?2l04alrz^Z}wuqu>sCuvG)Mev?%o|#{0LZAQcE?9#L!*ob4US z5DH}BkbGzY0(IcP>>E5fK@up`|Br(Bf2D&3Rs)iU zfc2svNe~!FU?mVlJPIO!vml0mhp^xx4K8>fC;T49$AXI+S`9wA0Q~<|5KHf|02eMW zjirJIK@}PWD?kzl3Lr$3ga`!i3|18$FektTkAW~mJOUI*0xtpK!LpGAc1i$?j35aF zK!G+~!|$=6fRCI6&>yBrlq7!DkjR6B(sXOu3`SP zNrM##WB>|9z&!Dw4^1gc!ofAo(qK+F_yGm02o@V28eD@yn-7@XVnN`4&e<z9>)1qV7q{4 z6|OCQZE}Aec2pqR=XnFzHGsnnEgzBu0d>+^)({#FjKEtPi1x`3v}_?T$21rj!q7HQ z#G<>QeR=>0G!KM<-5_|NK)?WKEk_6gABF(T8QA#G7VMocG-e3kallSXLx7zc?M?|G zy8_c$g#Pq>K)p01cVOv@EwKC2xFLQzN-$s=2FTC+$#Ky)f`zdN2ksI~7_IFE*3)9k z2Ur%|LM(b#+#=WCd+MLAK^55L;sAfYho6_O6Z!s_H*0*oj{7T0SbnrBBTQ5 z7n(R`WkeKsK|{qZp`uqt{7DhFgoY9a-g?nvEN2bBkduRn{&aeOn8R-%thk?}`3?Nz z0QeiY( zWho2_gF@laL^J^-iNPJ*g;>M@VZu%)64lkwh3ZJLhOpvjajY10gi3XlLLz^^5O;C6 z2VFp%W$S4Ja!vp2<7#UMS(9uWfC3i#@A^X>KJH{Y1jv2GB7o=k`2&st53I@#`UQhm z4g7A;9Z- zIUW{{M*oK4{^fxsz?;wVzBtqhFf6>R|H6|1UgmF@|I8Z-j{;H5UwwhE0b9Xx z9(V%kAD!ZfAP)WuPXY~s{J&v15a0d{!xR3+lSKUkBVhiqNfZGKEafkH1U$$p`Wr@s zPbcv2w_O3X{KEtIo`2{`;^AF&SzoX^fMfmzqq>tQj%0UQGQNhhoeM{gdQeI3RNB%+gR3$kLReTuR~7MpK&m0r diff --git a/notebooks/plots/descriptive_statistics/explainable_variance_bootstrapped_generalized.ipynb b/notebooks/plots/descriptive_statistics/explainable_variance_bootstrapped_generalized.ipynb deleted file mode 100644 index 9d01fbec..00000000 --- a/notebooks/plots/descriptive_statistics/explainable_variance_bootstrapped_generalized.ipynb +++ /dev/null @@ -1,236 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Script for Estimating the fraction of explained Variance with bootstrapping" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This script is doing the following:\n", - "- computing the explainable variance for a certain number of test image repeats\n", - "- bootstrapping this analysis by drawing random samples from image repeats \n", - "- It requires to have a list or numpy array of \"outputs\", which are the responses of the neurons for each repeat of each test image. \n", - "-- for example: np.array(n_images, n_repeats, n_neurons) or: \n", - "-- list(np.array[n_repeats, n_neurons]_image1, np.array[n_repeats, n_neurons]_image2, ... )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Measure Functions" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_explainable_var(outputs, per_neuron=False, eps=1e-9):\n", - " \"\"\"\n", - " Args:\n", - " outputs (array or list): repeated responses/targets to the same input. with the shape [inputs, ] [reps, neurons]\n", - " or array(inputs, reps, neurons)\n", - " per_neuron (bool): returns the explainable variance either as average across all neurons, or as a 1d array the size of n_neurons.\n", - " \n", - " Returns: the fraction of explainable variance\n", - " \"\"\"\n", - " \n", - " ImgVariance = []\n", - " TotalVar = np.var(np.vstack(outputs), axis=0, ddof=1)\n", - " for out in outputs:\n", - " ImgVariance.append(np.var(out, axis=0, ddof=1))\n", - " ImgVariance = np.vstack(ImgVariance)\n", - " NoiseVar = np.mean(ImgVariance, axis=0)\n", - " explainable_var = (TotalVar - NoiseVar) / (TotalVar + eps)\n", - " return explainable_var if per_neuron else np.mean(explainable_var)\n", - "\n", - "\n", - "def get_subset_of_repeats(outputs, repeat_limit=10, randomize=True):\n", - " \"\"\"\n", - " Args:\n", - " outputs (array or list): repeated responses/targets to the same input. with the shape [inputs, ] [reps, neurons]\n", - " or array(inputs, reps, neurons)\n", - " repeat_limit (int): how many reps are selected\n", - " randomize (cool): if True, takes a random selection of repetitions. if false, takes the first n repetitions.\n", - "\n", - " Returns: limited_outputs (list): same shape as inputs, but with reduced number of repetitions\n", - " \"\"\"\n", - " \n", - " limited_output = []\n", - " for repetitions in outputs:\n", - " n_repeats = repetitions.shape[0]\n", - " limited_output.append(repetitions[:repeat_limit, ] if not randomize else repetitions[\n", - " np.random.choice(n_repeats, repeat_limit if repeat_limit < n_repeats else n_repeats, replace=False)])\n", - " return limited_output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Parameters for the analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "# specifies the number of repeats that are tested, with increasing step size\n", - "n_repeats = np.hstack([np.arange(2,10), np.arange(10,20,2), np.arange(20,40,4)])\n", - "\n", - "# specifies how many samples are drawn for each test image.\n", - "# If the dataset is large, try 10 iterations. With more samples, the test gets more reliable. recommended: 30.\n", - "n_iters = 10" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running the Analysis" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "the variable outputs has to exist here." - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [], - "source": [ - "repeats, explainable_variance = [],[]\n", - "\n", - "for i in range(n_iters):\n", - " for reps in n_repeats:\n", - " \n", - " limited_outputs = get_subset_of_repeats(outputs, repeat_limit=reps)\n", - " score = compute_explainable_var(limited_outputs, per_neuron=False)\n", - " repeats.append(reps)\n", - " explainable_variance.append(score)" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.DataFrame({'repeats': repeats, \n", - " 'explainable variance': explainable_variance})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(7, 7))\n", - "sns.set_context('talk', font_scale=0.8)\n", - "\n", - "plt.grid(\"on\", ls='--')\n", - "sns.lineplot(x=\"repeats\", y=\"explainable variance\", data=df, ci=\"sd\", color='k')\n", - "\n", - "plt.title(\"Explainable Variance across repeats\");\n", - "plt.ylim([0.20, 0.40])\n", - "sns.despine(trim=True, offset=5)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "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 -}