File size: 10,172 Bytes
e11c92f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 | """RNN dms (delayed-match-to-sample)."""
from math import floor
import numpy as np
import torch
import matplotlib.pyplot as plt
from .modules import loss_mse
from .ranktwo import plot_field, plot_field_noscalings
# task constants
deltaT = 20.0
tau = 100
alpha = deltaT / tau
std_default = 3e-2
fixation_duration_min = 100
fixation_duration_max = 500
stimulus1_duration_min = 500
stimulus1_duration_max = 500
delay_duration_min = 500
delay_duration_max = 3000
stimulus2_duration_min = 500
stimulus2_duration_max = 500
decision_duration = 1000
# Defining some global variables, whoses values can also be set in setup
min_fixation_duration_discrete = floor(fixation_duration_min / deltaT)
max_fixation_duration_discrete = floor(fixation_duration_max / deltaT)
min_stimulus1_duration_discrete = floor(stimulus1_duration_min / deltaT)
max_stimulus1_duration_discrete = floor(stimulus1_duration_max / deltaT)
min_stimulus2_duration_discrete = floor(stimulus2_duration_min / deltaT)
max_stimulus2_duration_discrete = floor(stimulus2_duration_max / deltaT)
decision_duration_discrete = floor(decision_duration / deltaT)
min_delay_duration_discrete = floor(delay_duration_min / deltaT)
max_delay_duration_discrete = floor(delay_duration_max / deltaT)
total_duration = (
max_fixation_duration_discrete
+ max_stimulus1_duration_discrete
+ max_delay_duration_discrete
+ max_stimulus2_duration_discrete
+ decision_duration_discrete
)
def setup():
global min_fixation_duration_discrete
global max_fixation_duration_discrete
global min_stimulus1_duration_discrete
global max_stimulus1_duration_discrete
global min_stimulus2_duration_discrete
global max_stimulus2_duration_discrete
global decision_duration_discrete
global min_delay_duration_discrete
global max_delay_duration_discrete
global total_duration
min_fixation_duration_discrete = floor(fixation_duration_min / deltaT)
max_fixation_duration_discrete = floor(fixation_duration_max / deltaT)
min_stimulus1_duration_discrete = floor(stimulus1_duration_min / deltaT)
max_stimulus1_duration_discrete = floor(stimulus1_duration_max / deltaT)
min_stimulus2_duration_discrete = floor(stimulus2_duration_min / deltaT)
max_stimulus2_duration_discrete = floor(stimulus2_duration_max / deltaT)
decision_duration_discrete = floor(decision_duration / deltaT)
min_delay_duration_discrete = floor(delay_duration_min / deltaT)
max_delay_duration_discrete = floor(delay_duration_max / deltaT)
total_duration = (
max_fixation_duration_discrete
+ max_stimulus1_duration_discrete
+ max_delay_duration_discrete
+ max_stimulus2_duration_discrete
+ decision_duration_discrete
)
def generate_dms_data(
num_trials,
type=None,
gain=1.0,
fraction_validation_trials=0.2,
fraction_catch_trials=0.0,
std=std_default,
):
x = std * torch.randn(num_trials, total_duration, 2)
y = torch.zeros(num_trials, total_duration, 1)
mask = torch.zeros(num_trials, total_duration, 1)
types = ["A-A", "A-B", "B-A", "B-B"]
for i in range(num_trials):
if np.random.rand() > fraction_catch_trials:
if type is None:
cur_type = types[int(np.random.rand() * 4)]
else:
cur_type = type
if cur_type == "A-A":
input1 = gain
input2 = gain
choice = 1
elif cur_type == "A-B":
input1 = gain
input2 = 0
choice = -1
elif cur_type == "B-A":
input1 = 0
input2 = gain
choice = -1
elif cur_type == "B-B":
input1 = 0
input2 = 0
choice = 1
# Sample durations
delay_duration = np.random.uniform(delay_duration_min, delay_duration_max)
delay_duration_discrete = floor(delay_duration / deltaT)
fixation_duration = np.random.uniform(
min_fixation_duration_discrete, max_fixation_duration_discrete
)
fixation_duration_discrete = floor(fixation_duration / deltaT)
stimulus1_duration = np.random.uniform(stimulus1_duration_min, stimulus1_duration_max)
stimulus1_duration_discrete = floor(stimulus1_duration / deltaT)
stimulus2_duration = np.random.uniform(stimulus2_duration_min, stimulus2_duration_max)
stimulus2_duration_discrete = floor(stimulus2_duration / deltaT)
decision_time_discrete = (
fixation_duration_discrete
+ stimulus1_duration_discrete
+ delay_duration_discrete
+ stimulus2_duration_discrete
)
stim1_begin = fixation_duration_discrete
stim1_end = stim1_begin + stimulus1_duration_discrete
stim2_begin = stim1_end + delay_duration_discrete
stim2_end = stim2_begin + stimulus2_duration_discrete
x[i, stim1_begin:stim1_end, 0] += input1
x[i, stim1_begin:stim1_end, 1] += 1 - input1
x[i, stim2_begin:stim2_end, 0] += input2
x[i, stim2_begin:stim2_end, 1] += 1 - input2
y[
i, decision_time_discrete : decision_time_discrete + decision_duration_discrete
] = choice
mask[
i, decision_time_discrete : decision_time_discrete + decision_duration_discrete
] = 1
# Split
split_at = x.shape[0] - floor(x.shape[0] * fraction_validation_trials)
(x_train, x_val) = x[:split_at], x[split_at:]
(y_train, y_val) = y[:split_at], y[split_at:]
(mask_train, mask_val) = mask[:split_at], mask[split_at:]
return x_train, y_train, mask_train, x_val, y_val, mask_val
def accuracy_dms(output, targets, mask):
good_trials = (targets != 0).any(dim=1).squeeze() # eliminates catch trials
mask_bool = mask[good_trials, :, 0] == 1
targets_filtered = torch.stack(
targets[good_trials].squeeze()[mask_bool].chunk(good_trials.sum())
)
target_decisions = torch.sign(targets_filtered.mean(dim=1))
decisions_filtered = torch.stack(
output[good_trials].squeeze()[mask_bool].chunk(good_trials.sum())
)
decisions = torch.sign(decisions_filtered.mean(dim=1))
return (target_decisions == decisions).type(torch.float32).mean()
def map_device(tensors, net):
"""
Maps a list of tensors to the device used by the network net
:param tensors: list of tensors
:param net: nn.Module
:return: list of tensors
"""
if net.wi.device != torch.device("cpu"):
new_tensors = []
for tensor in tensors:
new_tensors.append(tensor.to(device=net.wi.device))
return new_tensors
else:
return tensors
def test_dms(net, x, y, mask):
x, y, mask = map_device([x, y, mask], net)
with torch.no_grad():
output, _ = net(x)
loss = loss_mse(output, y, mask).item()
acc = accuracy_dms(output, y, mask).item()
return loss, acc
def confusion_matrix(net):
matrix = np.zeros((4, 2))
rows = ["A-A", "B-B", "A-B", "B-A"]
for i, type in enumerate(rows):
x, y, mask, _, _, _ = generate_dms_data(100, type=type, fraction_validation_trials=0.0)
x, y, mask = map_device([x, y, mask], net)
output, _ = net(x)
mask_bool = mask[:, :, 0] == 1
decisions_filtered = torch.stack(output.squeeze()[mask_bool].chunk(output.shape[0]))
decisions = torch.sign(decisions_filtered.mean(dim=1))
matrix[i, 0] = (decisions < 0).sum().type(torch.float) / decisions.shape[0]
matrix[i, 1] = (decisions >= 0).sum().type(torch.float) / decisions.shape[0]
cols = ["different", "same"]
print("{:^12s}|{:^12s}|{:^12s}".format(" ", cols[0], cols[1]))
print("-" * 40)
for i, row in enumerate(rows):
print("{:^12s}|{:^12.2f}|{:^12.2f}".format(row, matrix[i, 0], matrix[i, 1]))
print("-" * 40)
def plot_trajectories(net, trajectories, ax, n_traj=2, style="-", c="C0", interval=[None, None]):
m1 = net.m[:, 0].detach().numpy()
m2 = net.m[:, 1].detach().numpy()
for j in range(n_traj):
proj1 = trajectories[j] @ m1 / net.hidden_size
proj2 = trajectories[j] @ m2 / net.hidden_size
if interval[1] != 0:
ax.plot(proj1[: interval[0]], proj2[: interval[0]], c=c, lw=4, linestyle=style)
def remove_axes(ax):
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["left"].set_visible(False)
ax.set(xticks=[], yticks=[])
def _plot_field(net, input, ax, sizes=1.0, rect=(-5, 5, -4, 4), scalings=False):
m1 = net.m[:, 0].detach().numpy()
m2 = net.m[:, 1].detach().numpy()
xmin, xmax, ymin, ymax = rect
if scalings:
plot_field(net, m1, m2, xmin, xmax, ymin, ymax, input=input, ax=ax, sizes=sizes)
else:
plot_field_noscalings(net, m1, m2, xmin, xmax, ymin, ymax, input=input, ax=ax, sizes=sizes)
remove_axes(ax)
def psychometric_matrix(net, n_trials=10, ax=None):
if ax is None:
fig, ax = plt.subplots()
stim1_begin = max_fixation_duration_discrete
stim1_end = max_fixation_duration_discrete + max_stimulus1_duration_discrete
stim2_begin = stim1_end + max_delay_duration_discrete
stim2_end = stim2_begin + max_stimulus2_duration_discrete
decision_end = stim2_end + decision_duration_discrete
mean_outputs = np.zeros((2, 2))
for inp1 in range(2):
for inp2 in range(2):
input = torch.zeros(n_trials, decision_end, 2)
input[:, stim1_begin:stim1_end, inp1] = 1
input[:, stim2_begin:stim2_end, inp2] = 1
output = net(input)
output = output.squeeze().detach().numpy()
mean_output = output[:, stim2_end:decision_end].mean()
mean_outputs[inp1, inp2] = mean_output
image = ax.matshow(mean_outputs, cmap="gray", vmin=-1, vmax=1)
ax.set_xticks([])
ax.set_yticks([])
return image
|