Commit 6cd5cde4 authored by Ines Filipa Fernandes Ramos's avatar Ines Filipa Fernandes Ramos
Browse files

added separate notebook_MEI_gen.ipynb

parent 24def916
......@@ -72,9 +72,9 @@ def fft_smooth(grad, factor=1/4):
tw = np.minimum(np.arange(0, w), np.arange(w-1, -1, -1), dtype=np.float32) # [-(w+2)//2:]
th = np.minimum(np.arange(0, h), np.arange(h-1, -1, -1), dtype=np.float32)
t = 1 / np.maximum(1.0, (tw[None, :] ** 2 + th[:, None] ** 2) ** (factor))
F = grad.new_tensor(t / t.mean()).unsqueeze(-1)
pp = torch.rfft(grad.data, 2, onesided=False)
return torch.irfft(pp * F, 2, onesided=False)
F = grad.new_tensor(t / t.mean()).unsqueeze(0)
pp = torch.fft.fft2(grad.data)
return torch.fft.ifft2(pp * F)
def blur1(img, sigma):
if sigma > 0:
......@@ -135,6 +135,7 @@ def make_step(net, src, step_size=1.5, sigma=None, precond=0, step_gain=1,
grad = src.grad
if precond > 0:
grad = fft_smooth(grad, precond)
grad = grad.real # added after deprecation of old torch.rfft() and torch.irfft() functions
# src.data += (step_size / (batch_mean(torch.abs(grad.data), keepdim=True) + eps)) * (step_gain / 255) * grad.data
src.data += (step_size / (torch.abs(grad.data).mean() + eps)) * (step_gain / 255) * grad.data
......@@ -344,96 +345,6 @@ def contrast_tuning(model, img, bias, scale, min_contrast=0.01, n=1000, linear=T
return cont, vals, lim_contrast
def MEI_multi_seed(dataset_name, dat, dataloaders, models, n_seeds, MEIParameter, TargetUnit, bk_color, init_gen_image, track=False):
"""
dataset_name : string # string with dataset_name of dataset used for training
dat : object # FileTreeDataset object with data schema of data
dataloaders : object # Dataloader object for dataset_name training data
models : object # Torch nn objects trained with dataset_name training data
n_seeds : int # number of distinct seeded models used
TargetUnit : int # index of model output neuron to generate MEI for
track : bool # plot graphs of model activation and generated images during gradient ascent
MEIProperties:
mei : longblob # most exciting images
activation : float # activation at the MEI
monotonic : bool # does activity increase monotonically with contrast
max_contrast : float # contrast at which maximum activity is achived
max_activation : float # activation at the maximum contrast
sat_contrast : float # contrast at which image would start saturating
img_mean : float # mean luminance of the image
lim_contrast : float # max reachable contrast without clipping
"""
neuron_id = TargetUnit
print('Working on neuron_id={}'.format(neuron_id))
# get input statistics
dataset, img_shape, bias, mu_beh, mu_eye, scale = prepare_data(dataloaders=dataloaders,dataset_name=dataset_name,dat=dat)
print('Working with images with mu={}, sigma={}'.format(bias, scale))
# get n instances of model for target unit
models = models[0:n_seeds]
adj_model = get_adj_model(models, neuron_id)
params = MEIParameter
blur = bool(params['blur'])
jitter = int(params['jitter'])
precond = float(params['precond'])
step_gain = float(params['step_gain'])
norm = float(params['norm'])
train_norm = float(params['train_norm'])
octaves = [
{
'iter_n': int(params['iter_n']),
'start_sigma': float(params['start_sigma']),
'end_sigma': float(params['end_sigma']),
'start_step_size': float(params['start_step_size']),
'end_step_size': float(params['end_step_size']),
},
]
# prepare initial image
channels, original_h, original_w = img_shape[-3:]
# the background color of the initial image
background_color = np.float32([bk_color] * channels)
# generate initial random image
if init_gen_image is not None:
gen_image = init_gen_image
else:
gen_image = np.random.normal(background_color, 8, (original_h, original_w, channels))
gen_image = np.clip(gen_image, 0, 255)
# generate class visualization via octavewise gradient ascent
gen_image = deepdraw(adj_model, gen_image, octaves, clip=True,
random_crop=False, blur=blur, jitter=jitter,
precond=precond, step_gain=step_gain,
bias=bias, scale=scale, norm=norm, train_norm=train_norm, track=track)
mei = gen_image.squeeze()
with torch.no_grad():
img = torch.Tensor(process(gen_image, mu=bias, sigma=scale)[None, ...]).to('cuda')
activation = adj_model(img).data.cpu().numpy()[0]
cont, vals, lim_contrast = contrast_tuning(adj_model, mei, bias, scale)
MEI = {
'neuron_id' : neuron_id,
'n_seeds' : n_seeds,
'mei' : mei,
'activation' : activation,
'monotonic' : bool(np.all(np.diff(vals) >= 0)),
'max_activation' : np.max(vals),
'max_contrast' : cont[np.argmax(vals)],
'sat_contrast' : np.max(cont),
'img_mean' : mei.mean(),
'lim_contrast' : lim_contrast,
}
return MEI
class multi_MEI_class:
"""
dataset_name : string # string with dataset_name of dataset used for training
......
......@@ -6834,7 +6834,7 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
......
......@@ -58652,7 +58652,7 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
......@@ -996,7 +996,7 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
......
......@@ -1729,7 +1729,7 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
......
%% Cell type:markdown id: tags:
# Demo Notebook with simulated RGCs data
%% Cell type:code id: tags:
``` python
%matplotlib inline
%load_ext autoreload
%autoreload 2
%load_ext memory_profiler
import torch
import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict
import neuralpredictors as neur
from neuralpredictors.data.datasets import StaticImageSet, FileTreeDataset
import MEI
import matplotlib as mpl
from datetime import date
from datetime import datetime
```
%%%% Output: stream
The autoreload extension is already loaded. To reload it, use:
%reload_ext autoreload
%% Cell type:markdown id: tags:
# Build the dataloaders
%% Cell type:markdown id: tags:
The dataloaders object is a dictionary of 3 dictionaries: train, validation and test.
%% Cell type:code id: tags:
``` python
#Use dataloaders with generated RGC data
from lurz2020.datasets.mouse_loaders import static_loaders
path = ['D://inception_loop/RGC_sim_data/data/static27012021']
dataset_config = {'paths': path,
'batch_size': 64,
'seed': 1,
'cuda': True,
'normalize': True,
'exclude': "images"}
dataloaders_RGCs = static_loaders(**dataset_config)
dat = FileTreeDataset('D://inception_loop/RGC_sim_data/data/static27012021', "images", "responses")
```
%% Cell type:code id: tags:
``` python
tier = 'train'
dataset_name = '27012021'
```
%% Cell type:markdown id: tags:
### Look at the data
%% Cell type:code id: tags:
``` python
tier = 'train'
dataset_name = '27012021'
images, responses = [], []
for data in dataloaders_RGCs[tier][dataset_name]:
images.append(data[0].squeeze().cpu().data.numpy())
responses.append(data[1].squeeze().cpu().data.numpy())
images = np.vstack(images)
responses = np.vstack(responses)
print('The \"{}\" set of dataset \"{}\" contains the responses of {} RGC neurons to {} images'.format(tier, dataset_name, responses.shape[1], responses.shape[0]))
```
%% Cell type:code id: tags:
``` python
# show some example images and the neural responses
n_images = 5
max_response = responses[:n_images].max()
for i in range(n_images):
fig, axs = plt.subplots(1, 2, figsize=(15,4))
axs[0].imshow(images[i])
axs[1].plot(responses[i])
axs[1].set_xlabel('neurons')
axs[1].set_ylabel('responses')
axs[1].set_ylim([0, max_response])
plt.show()
```
%% Cell type:markdown id: tags:
# Build the model, transfer core, train and evaluate performance - 4 instances
%% Cell type:markdown id: tags:
Get 4 instances of the model for MEI generation:
%% Cell type:code id: tags:
``` python
%%time
%%memit
from lurz2020.models.models import se2d_fullgaussian2d
from lurz2020.training.trainers import standard_trainer as trainer
from lurz2020.utility.measures import get_correlations, get_fraction_oracles, get_FEV
#Generate 4 instances of the same model with different seeds, for MEI generation
n_seeds = 4
models = []
train_correlation_models, validation_correlation_models, test_correlation_models = [], [], []
fraction_oracle = []
exp_var_models = []
model_state_before, model_state_after = [], []
#Model config
model_config_tunned = {'init_mu_range': 0.1,
'init_sigma': 0.64,
'input_kern': 15,
'hidden_kern': 13,
'gamma_input': 1.0,
'grid_mean_predictor': None,
'gamma_readout': 0.99}
#Change trainer config to not track and print the training progress
trainer_config = {'track_training': False,
'verbose': None,
'detach_core': True}
#Save information on training
#with open("D://inception_loop/RGC_sim_data/models/Train_log_.txt", "a") as log_file:
# comment = 'Comment: Results for tunned fullgaussian model with V1 core and readout trained with ephy data with only 2 good neurons with spatial rf. Shifter network used. Cropped images around rf location with padding.'
# date = "Date: " + datetime.now().strftime("%m/%d/%Y, %H:%M:%S")
# stim = "Stimuli dataset: " + dataset_name
# model_config = "Model configuration: " + str(model_config_tunned)
# log_file.write(comment+'\n'+date+'\n'+ stim+'\n'+model_config+'\n')
for i in range(n_seeds):
model = se2d_fullgaussian2d(**model_config_tunned, dataloaders=dataloaders_RGCs, seed=i)
#Load the weights of the transfer core
transfer_model = torch.load('D://inception_loop/original_code/Lurz_2020_code/notebooks/models/transfer_model.pth.tar')
model.load_state_dict(transfer_model, strict=False)
model_state_before.append(model.state_dict())
#Run training
score, output, model_state = trainer(model=model, dataloaders=dataloaders_RGCs, seed=1, **trainer_config)
model_state_after.append(model.state_dict())
#Get performance of model
train_correlation_models.append(get_correlations(model, dataloaders_RGCs["train"], device='cuda', as_dict=False, per_neuron=False))
validation_correlation_models.append(get_correlations(model, dataloaders_RGCs["validation"], device='cuda', as_dict=False, per_neuron=False))
test_correlation_models.append(get_correlations(model, dataloaders_RGCs["test"], device='cuda', as_dict=False, per_neuron=False))
oracle_dataloader = static_loaders(**dataset_config, return_test_sampler=True, tier='test')
fraction_oracle.append(get_fraction_oracles(model=model, dataloaders=oracle_dataloader, device='cuda')[0])
exp_var_models.append(get_FEV(model, oracle_dataloader, device='cuda', as_dict=False, per_neuron=False, threshold=None))
instance_results = '\n ----------------------------------------- \n \
Model instance #{0:1d} \n \
Correlation (train set): {1:.3f} \n \
Correlation (validation set): {2:.3f} \n \
Correlation (test set): {3:.3f} \n \
----------------------------------------- \n \
Fraction oracle (test set): {4:.3f} \n \
FEV (test set): {5:.3f} \n'.format(i, train_correlation_models[i], validation_correlation_models[i],
test_correlation_models[i], fraction_oracle[i], exp_var_models[i])
print(instance_results)
#with open("D://inception_loop/RGC_sim_data/models/Train_log_.txt", "a") as log_file:
# log_file.write("\n Model instances training results: \n"+ instance_results)
models.append(model)
#Save model state for loading later
#torch.save(model_state, 'D://inception_loop/RGC_sim_data/models/model_'+str(i)+'.pth')
```
%% Cell type:code id: tags:
``` python
#Print results of after training step
results = '\n Results for fullgaussian tunned model: \n \
----------------------------------------- \n \
{0:1d} instances of the model trained \n \
Mean correlation (train set): {1:.3f} \n \
Mean correlation (validation set): {2:.3f} \n \
Mean correlation (test set): {3:.3f} \n \
----------------------------------------- \n \
Mean fraction oracle (test set): {4:.3f} \n \
Mean FEV (test set): {5:.3f} \n '.format(len(train_correlation_models), np.mean(train_correlation_models),
np.mean(validation_correlation_models), np.mean(test_correlation_models), np.mean(fraction_oracle), np.mean(exp_var_models))
print(results)
#Save in train log file
#with open("D://inception_loop/RGC_sim_data/models/Train_log_.txt", "a") as log_file:
# log_file.write(results)
```
%% Cell type:markdown id: tags:
### Predict neural responses to an image (here from the train set)
%% Cell type:code id: tags:
``` python
# show some example images and the neural responses
n_images = 10
max_response = responses[:n_images].max()
for i in range(n_images):
input_image = images[i]
fig, axs = plt.subplots(1, 6, figsize=(20,4))
axs[0].imshow(input_image)
axs[1].plot(responses[i])
axs[1].set_title('real responses')
for n in range(len(models)):
predicted_response = models[n](torch.from_numpy(input_image).view(1,1,input_image.shape[0],input_image.shape[1]).cuda())
predicted_response = predicted_response.squeeze().cpu().data.numpy()
axs[n+2].plot(predicted_response)
axs[n+2].set_xlabel('neurons')
axs[n+2].set_title('predicted responses model '+str(n))
plt.tight_layout()
plt.show()
```
%% Cell type:markdown id: tags:
# Selection of neurons for MEI generation (use when input images have no padding)
# Selection of neurons for MEI generation (use instead of padding the input images)
%% Cell type:code id: tags:
``` python
%%time
#Selection of neurons for MEI generation -
#neurons in the top 50th percentile of oracle correlation and with similar predicted position of RF in the readout of the 4 models
#neurons with oracle correlation higher or equal to 0.9 and with similar predicted position of RF in the readout of the 4 models
from scipy.spatial.distance import pdist
from lurz2020.utility.measures import get_correlations, get_oracles
oracle_dataloader = static_loaders(**dataset_config, return_test_sampler=True, tier='test')
oracle_corr = get_oracles(oracle_dataloader["test"], as_dict=False, per_neuron=True)
neurons_for_MEI_padded = []
for neuron in range(len(oracle_corr)):
corr_models_neuron = []
mu_positions_neuron = []
for model in models:
corr_models_neuron.append(get_correlations(model, dataloaders_RGCs["test"], device="cuda", as_dict=False, per_neuron=True)[neuron])
mu_positions_neuron.append(model.readout[dataset_name].mu.cpu().detach().numpy()[0][neuron][0])
if min(corr_models_neuron) >= 0.9 and max(pdist(mu_positions_neuron)) <= 0.15:
neurons_for_MEI_padded.append(neuron)
np.save('D://inception_loop/RGC_sim_data/results/neurons_for_MEI_tunned_model_diff_RFs.npy', neurons_for_MEI_padded)
```
%% Cell type:code id: tags:
``` python
neurons_for_MEI_padded = np.load('D://inception_loop/RGC_sim_data/results/neurons_for_MEI_tunned_Fullgaussian.npy')
```
%% Cell type:markdown id: tags:
# MEI generation
%% Cell type:code id: tags:
``` python
#Load best tunned model instances - se2d_fullgaussian readout
from lurz2020.models.models import se2d_fullgaussian2d
n_seeds = 4
#Build model to load weights of instances
model_config_tunned = {'init_mu_range': 0.1,
'init_sigma': 0.64,
'input_kern': 15,
'hidden_kern': 13,
'gamma_input': 1.0,
'grid_mean_predictor': None,
'gamma_readout': 0.99}
models = []
for n in range(n_seeds):
model = se2d_fullgaussian2d(**model_config_tunned, dataloaders=dataloaders_RGCs, seed=n)
model_state = torch.load('D://inception_loop/RGC_sim_data/models/tunned_model_fullgaussian_corrected_'+str(n)+'.pth')
model.load_state_dict(model_state, strict=False)
if torch.cuda.is_available():
model.cuda()
model.eval()
models.append(model)
```
%% Cell type:code id: tags:
``` python
#Parameters for MEI generation
MEIParameter_tunned = {
#1000, 1.5, 0.01, 3.0, 0.125, 0.1, 0.1, 0, False, -1, 11.0)
'iter_n' : 1000, # int number of iterations to run
'start_sigma' : 2.34, # float starting sigma value
'end_sigma' : 0.16, # float ending sigma value
'start_step_size' : 3.0, # float starting step size
'end_step_size' : 0.125, # float ending step size
'precond' : 0.13, # float strength of gradient preconditioning filter falloff
'step_gain' : 0.1, # float scaling of gradient steps
'jitter' : 0, # int size of translational jittering
'blur' : True, # bool whether to apply bluring or not
'norm' : -1, # float norm adjustment after step, negative to turn off
'train_norm' : -1 # float norm adjustment during step, negative to turn off
}
```
%% Cell type:code id: tags:
``` python
# Generate multi MEI object
MEIS = MEI.multi_MEI_class(dataset_name = dataset_name, dat = dat, dataloaders = dataloaders_RGCs, models = models, n_seeds = 4, MEIParameter = MEIParameter_tunned)
```
%% Cell type:code id: tags:
``` python
# Generate MEIs for target neurons from selected models
targets_list = range(2)
for target in targets_list:
#Generate MEI for one target unit
MEIS.generate(target, track=True)
```
%%%% Output: stream
Working on neuron_id=0
Working with images with mu=111.30036163330078, sigma=60.936492919921875
getting image size:
starting drawing
%%%% Output: stream
D:\inception_loop\ines_code\MEI.py:76: UserWarning: The function torch.rfft is deprecated and will be removed in a future PyTorch release. Use the new torch.fft module functions, instead, by importing torch.fft and calling torch.fft.fft or torch.fft.rfft. (Triggered internally at ..\aten\src\ATen\native\SpectralOps.cpp:590.)
pp = torch.rfft(grad.data, 2, onesided=False)
D:\inception_loop\ines_code\MEI.py:77: UserWarning: The function torch.irfft is deprecated and will be removed in a future PyTorch release. Use the new torch.fft module functions, instead, by importing torch.fft and calling torch.fft.ifft or torch.fft.irfft. (Triggered internally at ..\aten\src\ATen\native\SpectralOps.cpp:602.)
return torch.irfft(pp * F, 2, onesided=False)
%%%% Output: stream
finished step 0 in octave 0
finished step 100 in octave 0
finished step 200 in octave 0
finished step 300 in octave 0
finished step 400 in octave 0
finished step 500 in octave 0
finished step 600 in octave 0
finished step 700 in octave 0
finished step 800 in octave 0
finished step 900 in octave 0
%%%% Output: stream
100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:08<00:00, 120.16it/s]
%%%% Output: stream
Working on neuron_id=1
Working with images with mu=111.30036163330078, sigma=60.936492919921875
getting image size:
starting drawing
finished step 0 in octave 0
finished step 100 in octave 0
finished step 200 in octave 0
finished step 300 in octave 0
finished step 400 in octave 0
finished step 500 in octave 0
finished step 600 in octave 0
finished step 700 in octave 0
finished step 800 in octave 0
finished step 900 in octave 0
%%%% Output: stream
100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:08<00:00, 118.30it/s]
%%%% Output: display_data
![](data:image/png;base64,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)
%%%% Output: display_data
![](data:image/png;base64,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