def wrapper(*args,**kwargs):
# Load configuration if experiment is specified
update_params = {}
if 'experiment' in kwargs:
exp_id = kwargs['experiment']
with open('utils/experiments.yml','r') as conf_file:
loaded_yaml = yaml.load(conf_file)
loaded_params = loaded_yaml.get(exp_id,{})
if 'model_exp_ids' in loaded_params:
if isinstance(loaded_params['model_exp_ids'],list):
pass
# Filter configuration params and update by **kwargs
varnames = func.__code__.co_varnames
for key,value in loaded_params.items():
if key in varnames:
update_params[key] = value
update_params.update(kwargs)
print(update_params)
kwargs = update_params
# Load model if net path in args
if 'net' in kwargs and isinstance(kwargs['net'],str):
kwargs['net'] = NDN.load_model(kwargs['net'])
# Load dataset
if 'dataset' in kwargs and isinstance(kwargs['dataset'],str):
kwargs['dataset'] = get_data_loader(kwargs['dataset'])
return func(**kwargs)
def plot_invariance_summary(net,
chosen_neurons,
perc,
experiment='000',
mask=False,
max_error=0.05,
num_samples=8,
scale_first_separately=False):
"""
Generate invariances from generator for all `chosen_neurons` and plot them in common summary with MEIs
Parameters:
net (NDN): trained Neural network
chosen_neurons (List[int]): neuron IDs
perc (float): Target percentage of MEI activation
experiment (str): experiment ID
mask (bool): If true stimuli will be masked on a plot
max_error (float): Max deviation from target activation
num_samples (int): number of samples for each neuron
"""
row_names = [str(n) for n in chosen_neurons]
mei = np.load(f'output/04_mei/{experiment}_mei_n.npy')
mei_act = np.load(f'output/04_mei/{experiment}_mei_activations_n.npy')
size_x, size_y = net.input_sizes[0][1:]
titles = []
all_images = []
for neuron in chosen_neurons:
generator = NDN.load_model(
f'output/08_generators/{experiment}_neuron{neuron}_generator.pkl')
noise_shape = generator.input_sizes[0][1]
noise_input = np.random.uniform(-2, 2, size=(1000, noise_shape))
invariances = generator.generate_prediction(noise_input)
images, activations = choose_representant(
num_samples,
net,
neuron,
invariances,
activation_lowerbound=(perc - max_error) *
mei_act[neuron] if perc is not None else -np.inf,
activation_upperbound=(perc + max_error) *
mei_act[neuron] if perc is not None else np.inf)
#print(mask_stimuli)
images[0] = np.reshape(mask_stimuli(mei[[neuron]], experiment, neuron),
(1, -1))
all_images.append(images)
activations[0] = mei_act[neuron]
titles += [f'{act/activations[0]:.2f}' for act in activations]
all_images = np.reshape(np.vstack(all_images), (-1, size_x, size_y))
plot_grid(
all_images,
titles,
num_cols=num_samples,
save_path=f'output/08_generators/{experiment}_invariance_overview.png',
show=False,
row_names=row_names,
scale_first_separately=scale_first_separately,
ignore_assertion=True)
def compute_mask(net: NDN, images: np.array, try_pixels=range(0, 2, 1)):
"""
Computes ROI/masks
Parameters:
net (NDN): A trained neural network
images (np.array): Images to be presented to the `net` with changing values of pixel luminance
try_pixels (iterable): Iterable object of values of pixel luminance to add on `images`
Returns:
mask (np.array): Array of masks for each neuron
"""
num_images, num_pixels = np.shape(images)
activations = net.generate_prediction(images)
mask = np.zeros(num_pixels)
net.batch_size = 512
size_x, size_y = net.input_sizes[0][1:]
size_out = net.output_sizes[0]
# Generate images by changing single pixel value
inputs = []
for pixel_position in tqdm(range(num_pixels)):
for i, pixel in enumerate(try_pixels):
modified_images = np.copy(images)
modified_images[:, pixel_position] += np.repeat(pixel, num_images)
inputs.append(modified_images)
modified_images = np.vstack(inputs)
# Predict and subtract base activation
predicted_activations = net.generate_prediction(modified_images)
differences = predicted_activations - \
np.tile(activations, (len(try_pixels)*num_pixels, 1))
# Compute std of each pixel and arrange result into grid shaped like stimuli
differences = np.reshape(differences, (size_x, size_y, -1, size_out))
mask = np.std(differences, axis=2).transpose((2, 0, 1))
return mask
def plot_from_generator(net,
neuron,
num_representants,
experiment='000',
include_mei=False,
mask=False,
max_error=0.05,
perc=0.95):
"""
Generate and plot invariances from generator
Parameters:
net (NDN): trained Neural network
neuron (int): neuron ID
num_representants (int): number of represntats to plot
experiment (str): experiment ID
include_mei (bool): If true MEI will be placed as last image in the figure
mask (bool): If true stimuli will be masked on a plot
max_error (float): Max deviation from target activation
perc (float): Target percentage of MEI activation
"""
inputs = []
generator = NDN.load_model(
f'output/08_generators/{experiment}_neuron{neuron}_generator.pkl')
_, input_size_x, input_size_y = net.input_sizes[0]
noise_shape = input_size_x
mei_act = np.load(
f'output/04_mei/{experiment}_mei_activations_n.npy')[neuron]
noise_input = np.random.uniform(-2, 2, size=(10000, noise_shape))
invariances = generator.generate_prediction(noise_input)
images, activations = choose_representant(
num_representants,
net,
neuron,
invariances,
activation_lowerbound=(perc - max_error) * mei_act,
activation_upperbound=(perc + max_error) * mei_act)
np.save(
f'output/06_invariances/{experiment}_neuron{neuron}_equivariance.npy',
np.reshape(images, (-1, input_size_x, input_size_y)))
np.save(
f'output/06_invariances/{experiment}_neuron{neuron}_activations.npy',
activations)
plot_invariances(experiment=experiment,
neuron=neuron,
include_mei=include_mei,
mask=mask)
def plot_interpolations(net,
neuron,
experiment='000',
mask=False,
num_interpolations=3,
num_samples=6):
"""
Generate invariances from diameters of unit sphere in latent space
Parameters:
net (NDN): trained Neural network
neuron (int): neuron ID
experiment (str): experiment ID
mask (bool): If true stimuli will be masked on a plot
num_interpolations (int): number of diameters
num_samples (int): number of sampled points from diameter
"""
inputs = []
generator = NDN.load_model(
f'output/08_generators/{experiment}_neuron{neuron}_generator.pkl')
size_x, size_y = net.input_sizes[0][1:]
noise_shape = generator.input_sizes[0][1]
mei_act = np.load(
f'output/04_mei/{experiment}_mei_activations_n.npy')[neuron]
# Generate points on sphere
for i in range(num_interpolations):
first_point = np.random.normal(0.0, 1.0, noise_shape)
first_point /= np.linalg.norm(first_point, axis=0)
inputs.append(np.linspace(first_point, -first_point, num_samples))
noise_samples = np.vstack(inputs)
# Predict
invariances = generator.generate_prediction(noise_samples)
mask_text = ''
if mask:
invariances = mask_stimuli(invariances, experiment, neuron)
mask_text = '_masked'
activations = net.generate_prediction(invariances)[:, neuron]
titles = [f'{act/mei_act:.2f}' for act in activations]
invariances = np.reshape(invariances, (-1, size_x, size_y))
plot_grid(
invariances,
titles,
num_cols=6,
save_path=
f'output/06_invariances/{experiment}_{neuron}_interpolations_plot{mask_text}.png',
show=False)
def extract_generator(self):
# Extracts generator as a simple 1-layer net with biases
generator_subnet = NDN([
copy.deepcopy(
self.net_with_generator.network_list[self.generator_subnet_id])
],
noise_dist='max',
input_dim_list=[
self.net_with_generator.network_list[
self.generator_subnet_id]['input_dims']
])
# Copy weights
GeneratorNet._copy_net_params(self.net_with_generator,
generator_subnet,
self.generator_subnet_id, 0)
if self.current_norm == 'post':
generator_subnet.networks[-1].layers[-1].normalize_output = True
return generator_subnet
def plot_sphere_samples(net,
neuron,
experiment='000',
mask=False,
num_samples=18):
"""
Generate invariances from points in latent space uniformly sampled from unit sphere
Parameters:
dataset (DataLoader): dataset
net (NDN): trained Neural network
experiment (str): experiment ID
mask (bool): If true stimuli will be masked on a plot
num_samples (int): number of samples from unit sphere in latent space
"""
inputs = []
generator = NDN.load_model(
f'output/08_generators/{experiment}_neuron{neuron}_generator.pkl')
size_x, size_y = net.input_sizes[0][1:]
noise_shape = generator.input_sizes[0][1]
mei_act = np.load(
f'output/04_mei/{experiment}_mei_activations_n.npy')[neuron]
noise_samples = sample_sphere(noise_shape, num_samples)
invariances = generator.generate_prediction(noise_samples)
mask_text = ''
if mask:
invariances = mask_stimuli(invariances, experiment, neuron)
mask_text = '_masked'
activations = net.generate_prediction(invariances)[:, neuron]
titles = [f'{act/mei_act:.2f}' for act in activations]
invariances = np.reshape(invariances, (-1, size_x, size_y))
plot_grid(
invariances,
titles,
num_cols=6,
save_path=
f'output/06_invariances/{experiment}_{neuron}_sphere_plot{mask_text}.png',
show=False)
def compare_generators(neuron,
net,
experiment='000',
generator_experiment=[],
generator_names=[],
percentage=[],
num_per_net=6,
mask=False,
max_error=0.05):
"""
Compare generators from different experiments on same neuron and plot results. Experiments must share net and dataset parameters
Parameters:
neuron (int): neuron ID
net (NDN): trained Neural network
experiment (str): experiment ID
generator_experiment (List[str]): List of experiment IDs to compare
generator_names (List[str]): List of generator names. Will be displayed on a plot
percentage (List[float]): list of target percentage of MEI for each experiment
num_per_net (int): Number of representants per experiment
mask (bool): If true stimuli will be masked on a plot
max_error (float): Max deviation from target activation
"""
images = []
titles = []
base_exp = generator_experiment[0]
mei_act = np.load(
f'output/04_mei/{base_exp}_mei_activations_n.npy')[neuron]
noise_input = np.random.uniform(-2, 2, size=(10000, 128))
mei = np.load(f'output/04_mei/{base_exp}_mei_n.npy')[neuron]
size_x, size_y = net.input_sizes[0][1:]
for generator_exp, generator_name, perc in zip(generator_experiment,
generator_names,
percentage):
generator = NDN.load_model(
f'output/08_generators/{generator_exp}_neuron{neuron}_generator.pkl'
)
invariances = generator.generate_prediction(noise_input)
invariances, activations = choose_representant(
num_per_net,
net,
neuron,
invariances,
activation_lowerbound=(perc - max_error) *
mei_act if perc is not None else -np.inf,
activation_upperbound=(perc + max_error) *
mei_act if perc is not None else np.inf)
if len(invariances) < num_per_net:
raise ValueError('Cannot generate samples with given conditions')
images.append(invariances)
titles += list(activations)
images.append(np.reshape(mei, (1, -1)))
images = np.vstack(images)
titles.append(mei_act)
titles = [f'{tit/mei_act:.2f}' for tit in titles]
images = np.reshape(images, (-1, size_x, size_y))
if mask:
images = mask_stimuli(images, base_exp, neuron)
plot_grid(
images,
titles,
num_cols=num_per_net,
save_path=f'output/08_generators/neuron{neuron}_compare_generator.png',
row_names=generator_names + ['MEI'],
ignore_assertion=True)
def train_MEI(net: NDN, input_data, output_data, data_filters, opt_args,
fit_vars, var_layer):
"""
Optimization of weights in variable layer to maximize neurons output
Parameters:
net (NDN): A trained neural network with variable layer
input_data (np.array): input data
output_data (np.array): output data
data_filters (np.array): data_filters will be passed to NDN.train
opt_args (dict): optimizer arguments
fit_vars (dict): fit variables will be passed to NDN.train
var_layer (NDN.Layer): Variable layer
"""
opt_params = net.optimizer_defaults(opt_args['opt_params'],
opt_args['learning_alg'])
epochs = opt_args['opt_params']['epochs_training']
lr = opt_args['opt_params']['learning_rate']
_, sizex, sizey = net.input_sizes[0]
input_data, output_data, data_filters = net._data_format(
input_data, output_data, data_filters)
net._build_graph(opt_args['learning_alg'],
opt_params,
fit_vars,
batch_size=1)
with tf.Session(graph=net.graph, config=net.sess_config) as sess:
# Define train step
train_step, learning_rate = define_mei_train_step(
net, var_layer, sizex, sizey, 0.1)
# Restore parameters and setup metrics
net._restore_params(sess, input_data, output_data, data_filters)
i = 0
cost = float('inf')
best_cost = float('inf')
without_increase = 0
# Training
while without_increase < 100 and i < epochs:
sess.run(train_step,
feed_dict={
net.indices: [0],
learning_rate: lr
})
cost = sess.run(net.cost, feed_dict={net.indices: [0]})
cost_reg = sess.run(net.cost_reg, feed_dict={net.indices: [0]})
if i % 20 == 0:
print(
f'Cost: {cost:.5f}+{cost_reg:.5f}, best: {best_cost:.3f}')
if i % 10 == 0:
# Apply gausssian blur
sess.run(
var_layer.gaussian_blur_std_var.assign(
var_layer.gaussian_blur_std_var * 0.99))
if cost < best_cost:
best_cost = cost + cost_reg
without_increase = 0
sess.run(var_layer.gaussian_blur)
i += 1
without_increase += 1
# Save trained weights
net._write_model_params(sess)
print(f'Trained with {i} epochs')
def __init__(self,
original_nets,
input_noise_size,
loss='oneside-gaussian',
norm='online',
is_aegan=False,
mask=None,
gen_type='conv'):
# Save parameters
if not isinstance(original_nets, list):
original_nets = [original_nets]
self.original_nets = [copy.deepcopy(net) for net in original_nets]
self.noise_size = input_noise_size
self.is_aegan = is_aegan
if norm not in ['online', 'post', 'none']:
raise ValueError(
f'Incorrect norm \'{norm}\'. Norm should be one of online/post/none'
)
self.current_norm = norm
# Assert all networks has only one input of a same shape
input_stimuli_size = self.original_nets[-1].input_sizes[0]
for i, network in enumerate(self.original_nets):
assert len(
network.input_sizes
) == 1, f'Network {i} has more than one input. Input sizes: {network.input_sizes}.'
assert input_stimuli_size == network.input_sizes[
0], f'Network {i} has different input shape. Expected {input_stimuli_size}, given {network.input_sizes}'
# Create generator
generator = self.get_gan_subnet(input_noise_size, input_stimuli_size,
gen_type)
self.generator_subnet_id = 0
merged_networks = [generator]
net_prefix_num = 1
# Merge networks and rewire inputs
ffnet_out = []
losses = []
network_mapping = []
for i_net, network in enumerate(self.original_nets):
for i_subnet, subnetwork in enumerate(network.network_list):
network_mapping.append(
((i_net, i_subnet), len(merged_networks)))
if subnetwork['ffnet_n'] is not None:
subnetwork['ffnet_n'] = [
f + net_prefix_num for f in subnetwork['ffnet_n']
]
if subnetwork['xstim_n'] is not None:
subnetwork['xstim_n'] = None
subnetwork['ffnet_n'] = [0]
merged_networks.append(subnetwork)
out_nets = [
len(network.network_list) - 1 if x == -1 else x
for x in network.ffnet_out
]
ffnet_out += [f + net_prefix_num for f in out_nets]
losses.append(loss)
net_prefix_num += len(network.network_list)
# Optionally create decoder
self.encoder_subnet_id = None
if is_aegan:
ffnet_out += [len(merged_networks)]
merged_networks.append(
self.get_encoder(input_noise_size, input_stimuli_size, 0))
self.encoder_subnet_id = len(merged_networks) - 1
losses.append('gaussian')
# Define new NDN
self.net_with_generator = NDN(
merged_networks,
input_dim_list=[[1, input_noise_size]],
batch_size=self.original_nets[0].batch_size
if self.original_nets[0].batch_size is not None else 265,
ffnet_out=ffnet_out,
noise_dist=losses,
tf_seed=250)
# Copy weight from original net
for (i_net, i_subnet), target_i_net in network_mapping:
GeneratorNet._copy_net_params(self.original_nets[i_net],
self.net_with_generator, i_subnet,
target_i_net)
# Set mask
if mask is None:
# Set all ones mask = no change of input
mask = np.ones(input_stimuli_size, dtype=np.float32)
self.net_with_generator.networks[0].layers[-1].weights = mask.astype(
np.float32)
# Construct fit vars
layers_to_skip = []
for i, net in enumerate(self.net_with_generator.networks):
if i == self.generator_subnet_id:
# Fit all except mask
layers_to_skip.append([len(net.layers) - 1])
elif i == self.encoder_subnet_id:
# Fit all
layers_to_skip.append([])
else:
# Freeze weights
layers_to_skip.append([x for x in range(len(net.layers))])
self.generator_fit_vars = self.net_with_generator.fit_variables(
layers_to_skip=layers_to_skip, fit_biases=False)
class GeneratorNet:
def __init__(self,
original_nets,
input_noise_size,
loss='oneside-gaussian',
norm='online',
is_aegan=False,
mask=None,
gen_type='conv'):
# Save parameters
if not isinstance(original_nets, list):
original_nets = [original_nets]
self.original_nets = [copy.deepcopy(net) for net in original_nets]
self.noise_size = input_noise_size
self.is_aegan = is_aegan
if norm not in ['online', 'post', 'none']:
raise ValueError(
f'Incorrect norm \'{norm}\'. Norm should be one of online/post/none'
)
self.current_norm = norm
# Assert all networks has only one input of a same shape
input_stimuli_size = self.original_nets[-1].input_sizes[0]
for i, network in enumerate(self.original_nets):
assert len(
network.input_sizes
) == 1, f'Network {i} has more than one input. Input sizes: {network.input_sizes}.'
assert input_stimuli_size == network.input_sizes[
0], f'Network {i} has different input shape. Expected {input_stimuli_size}, given {network.input_sizes}'
# Create generator
generator = self.get_gan_subnet(input_noise_size, input_stimuli_size,
gen_type)
self.generator_subnet_id = 0
merged_networks = [generator]
net_prefix_num = 1
# Merge networks and rewire inputs
ffnet_out = []
losses = []
network_mapping = []
for i_net, network in enumerate(self.original_nets):
for i_subnet, subnetwork in enumerate(network.network_list):
network_mapping.append(
((i_net, i_subnet), len(merged_networks)))
if subnetwork['ffnet_n'] is not None:
subnetwork['ffnet_n'] = [
f + net_prefix_num for f in subnetwork['ffnet_n']
]
if subnetwork['xstim_n'] is not None:
subnetwork['xstim_n'] = None
subnetwork['ffnet_n'] = [0]
merged_networks.append(subnetwork)
out_nets = [
len(network.network_list) - 1 if x == -1 else x
for x in network.ffnet_out
]
ffnet_out += [f + net_prefix_num for f in out_nets]
losses.append(loss)
net_prefix_num += len(network.network_list)
# Optionally create decoder
self.encoder_subnet_id = None
if is_aegan:
ffnet_out += [len(merged_networks)]
merged_networks.append(
self.get_encoder(input_noise_size, input_stimuli_size, 0))
self.encoder_subnet_id = len(merged_networks) - 1
losses.append('gaussian')
# Define new NDN
self.net_with_generator = NDN(
merged_networks,
input_dim_list=[[1, input_noise_size]],
batch_size=self.original_nets[0].batch_size
if self.original_nets[0].batch_size is not None else 265,
ffnet_out=ffnet_out,
noise_dist=losses,
tf_seed=250)
# Copy weight from original net
for (i_net, i_subnet), target_i_net in network_mapping:
GeneratorNet._copy_net_params(self.original_nets[i_net],
self.net_with_generator, i_subnet,
target_i_net)
# Set mask
if mask is None:
# Set all ones mask = no change of input
mask = np.ones(input_stimuli_size, dtype=np.float32)
self.net_with_generator.networks[0].layers[-1].weights = mask.astype(
np.float32)
# Construct fit vars
layers_to_skip = []
for i, net in enumerate(self.net_with_generator.networks):
if i == self.generator_subnet_id:
# Fit all except mask
layers_to_skip.append([len(net.layers) - 1])
elif i == self.encoder_subnet_id:
# Fit all
layers_to_skip.append([])
else:
# Freeze weights
layers_to_skip.append([x for x in range(len(net.layers))])
self.generator_fit_vars = self.net_with_generator.fit_variables(
layers_to_skip=layers_to_skip, fit_biases=False)
def train_generator_on_neuron(self,
optimize_neuron,
data_len,
max_activation=None,
perc=0.9,
epochs=5,
noise_input=None,
output=None,
train_log=None):
if output is not None and noise_input is None:
raise ValueError('Output specified, but no input provided')
# Create input if not specified
if noise_input is None:
input_shape = (data_len, self.noise_size)
# Create input
noise_input = np.random.normal(size=input_shape, scale=1)
# TODO: Is normalizing necesary?
#input_norm = np.sqrt(np.sum(noise_input**2,axis=1))/np.sqrt(self.noise_size)
else:
noise_input = noise_input
# Create output if not specified
if output is None:
output_shape = (data_len, self.net_with_generator.output_sizes[0])
# Create_output
output = np.zeros(output_shape)
if max_activation is not None:
output[:, optimize_neuron] = output[:, optimize_neuron] + \
(perc*np.ones(output_shape[0]) * max_activation)
# Setup data filter to filter only desired neuron
tmp_filters = np.zeros(
(data_len, self.net_with_generator.output_sizes[0]))
tmp_filters[:, optimize_neuron] = 1
output = [output]
tmp_filters = [tmp_filters]
if self.encoder_subnet_id is not None:
output.append(noise_input)
tmp_filters.append(np.ones((data_len, self.noise_size)))
print(len(output))
# Set L2-norm on output
if self.current_norm == 'online':
# if not isinstance(l2_norm,list):
# l2_norm = [l2_norm]
# if not self.is_aegan:
self.net_with_generator.networks[
self.generator_subnet_id].layers[-1].normalize_output = True
# else:
# self.net_with_generator.networks[-1].layers[0].normalize_output = l2_norm
# Generator training
self.net_with_generator.train(noise_input,
output,
fit_variables=self.generator_fit_vars,
data_filters=tmp_filters,
learning_alg='adam',
train_indxs=np.arange(data_len * 0.9),
test_indxs=np.arange(
data_len * 0.9, data_len),
output_dir=train_log,
opt_params={
'display': 1,
'batch_size': 256,
'epochs_summary': 1,
'use_gpu': False,
'epochs_training': epochs,
'learning_rate': 0.0001
})
# print(self.net_with_generator.eval_preds(noise_input,output_data=output))
def extract_generator(self):
# Extracts generator as a simple 1-layer net with biases
generator_subnet = NDN([
copy.deepcopy(
self.net_with_generator.network_list[self.generator_subnet_id])
],
noise_dist='max',
input_dim_list=[
self.net_with_generator.network_list[
self.generator_subnet_id]['input_dims']
])
# Copy weights
GeneratorNet._copy_net_params(self.net_with_generator,
generator_subnet,
self.generator_subnet_id, 0)
if self.current_norm == 'post':
generator_subnet.networks[-1].layers[-1].normalize_output = True
return generator_subnet
def generate_stimulus(self, num_samples=1000, noise_input=None):
# Generate noise_input if not specified
if noise_input is None:
noise_input = np.random.uniform(-2,
2,
size=(num_samples,
self.noise_size))
generator = self.extract_generator()
image_out = generator.generate_prediction(noise_input)
return image_out
@staticmethod
def _copy_net_params(original_NDN_net, target_NDN_net, net_num_original,
net_num_target):
for layer_source, layer_target in zip(
original_NDN_net.networks[net_num_original].layers,
target_NDN_net.networks[net_num_target].layers):
layer_target.copy_layer_params(layer_source)
def get_gan_subnet(self,
input_noise_size,
output_shape,
generator_type='conv'):
output_shape = output_shape[1:]
layers = 5
if generator_type == 'conv':
params = NDNutils.ffnetwork_params(
input_dims=[1, input_noise_size],
layer_sizes=[[64, 8, 8], 32, 16, 1, 1],
layer_types=['normal', 'deconv', 'deconv', 'deconv', 'mask'],
act_funcs=['relu', 'relu', 'relu', 'tanh', 'lin'],
conv_filter_widths=[None, 5, 5, 5, None],
shift_spacing=[None, 2, 2, 1, None],
reg_list={'d2x': [None, None, 0.01, 0.01, None]},
verbose=False)
params['output_shape'] = [
None, None, output_shape, output_shape, None
]
elif generator_type == 'deepconv':
params = NDNutils.ffnetwork_params(
input_dims=[1, input_noise_size],
layer_sizes=[[512, 4, 4], 256, 128, 1, 1],
layer_types=['normal', 'deconv', 'deconv', 'deconv', 'mask'],
act_funcs=['relu', 'relu', 'relu', 'tanh', 'lin'],
conv_filter_widths=[None, 5, 5, 5, None],
shift_spacing=[None, 2, 2, 2, None],
reg_list={'d2x': [None, None, None, 0.01, None]},
verbose=False)
params['output_shape'] = [None, None, None, output_shape, None]
elif generator_type == 'lin' or generator_type == 'lin_tanh':
act = 'lin' if generator_type == 'lin' else 'tanh'
params = NDNutils.ffnetwork_params(
input_dims=[1, input_noise_size],
layer_sizes=[512, 1024, [1, 31, 31], 1],
layer_types=['normal', 'normal', 'normal', 'mask'],
act_funcs=['tanh', 'tanh', act, 'lin'],
reg_list={
'l2': [0.01, 0.01, 0.01, None],
},
verbose=False)
layers = 4
elif generator_type == 'hybrid':
params = NDNutils.ffnetwork_params(
input_dims=[1, input_noise_size],
layer_sizes=[256, [16, 16, 16], 8, 1, 1],
layer_types=['normal', 'normal', 'deconv', 'deconv', 'mask'],
act_funcs=['relu', 'relu', 'relu', 'tanh', 'lin'],
conv_filter_widths=[None, 5, 5, 5, None],
shift_spacing=[None, 2, 2, 1, None],
reg_list={'d2x': [None, None, 0.01, 0.01, None]},
verbose=False)
params['output_shape'] = [
None, None, output_shape, output_shape, None
]
else:
raise ValueError(
f'Generator type \'{generator_type}\' not implemented.')
params['xstim_n'] = [0]
params['normalize_output'] = [None] * layers
params['weights_initializers'] = ['normal'] * (layers - 1) + ['ones']
params['biases_initializers'] = ['zeros'] * layers
return params
def get_encoder(self,
noise_size,
input_shape,
ffnet_in,
generator_type='conv'):
if generator_type == 'conv':
params = NDNutils.ffnetwork_params(
input_dims=input_shape,
layer_sizes=[8, 8, 16, noise_size],
layer_types=['conv', 'conv', 'conv', 'normal'],
act_funcs=['relu', 'relu', 'relu', 'lin'],
conv_filter_widths=[5, 5, 7, None],
shift_spacing=[1, 2, 2, None],
reg_list={'d2x': [0.1, 0.1, None, None]},
verbose=False)
elif generator_type == 'lin':
params = NDNutils.ffnetwork_params(
input_dims=input_shape,
layer_sizes=[8, 8, 16, noise_size],
layer_types=['normal', 'normal', 'normal'],
act_funcs=[
'relu',
'relu',
'relu',
],
reg_list={'d2x': [0.1, 0.1, None, None]},
verbose=False)
elif generator_type == 'hybrid':
params = NDNutils.ffnetwork_params(
input_dims=input_shape,
layer_sizes=[8, 8, 16, noise_size],
layer_types=['conv', 'conv', 'normal', 'normal'],
act_funcs=['relu', 'relu', 'relu', 'lin'],
conv_filter_widths=[5, 5, 7, None],
shift_spacing=[2, 2, None, None],
reg_list={'d2x': [0.1, 0.1, None, None]},
verbose=False)
else:
raise ValueError(
f'Generator type \'{generator_type}\' not implemented.')
params['xstim_n'] = None
params['ffnet_n'] = [ffnet_in]
return params