def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0):
super().__init__(dt=dt)
self.choices = [1, 2]
self.cues = [0, 1]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'sample': 500,
'delay1': 500,
'cue1': 500,
'test1': 500,
'delay2': 500,
'cue2': 500,
'test2': 500}
if timing:
self.timing.update(timing)
self.abort = False
name = {'fixation': 0, 'stimulus1': range(1, 3),
'stimulus2': range(3, 5), 'cue1': 5, 'cue2': 6}
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(7,),
dtype=np.float32, name=name)
name = {'fixation': 0, 'match': 1, 'non-match': 2}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self, dt=80, rewards=None, timing=None, gain=1,
prod_margin=0.2):
super().__init__(dt=dt)
self.prod_margin = prod_margin
self.gain = gain
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 100,
'ready': 83,
'measure': lambda: self.rng.uniform(800, 1500),
'set': 83}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
name = {'fixation': 0, 'ready': 1, 'set': 2}
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(3,),
dtype=np.float32, name=name)
name = {'fixation': 0, 'go': 1}
self.action_space = spaces.Discrete(2, name=name) # (fixate, go)
def __init__(self, dt=100, anti=True, rewards=None, timing=None,
dim_ring=16, reaction=False):
super().__init__(dt=dt)
self.anti = anti
self.reaction = reaction
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'stimulus': 500,
'delay': 0,
'decision': 500}
if timing:
self.timing.update(timing)
self.abort = False
# action and observation spaces
self.dim_ring = dim_ring
self.theta = np.arange(0, 2 * np.pi, 2 * np.pi / dim_ring)
self.choices = np.arange(dim_ring)
name = {'fixation': 0, 'stimulus': range(1, dim_ring + 1)}
self.observation_space = spaces.Box(
-np.inf, np.inf, shape=(1+dim_ring,), dtype=np.float32, name=name)
name = {'fixation': 0, 'choice': range(1, dim_ring + 1)}
self.action_space = spaces.Discrete(1+dim_ring, name=name)
def __init__(self, dt=100, rewards=None, timing=None, sigma=1):
super().__init__(dt=dt)
# Possible decisions at the end of the trial
self.choices = [1, 2] # e.g. [left, right]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Optional rewards dictionary
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
# Optional timing dictionary
# if provided, self.add_period can infer timing directly
self.timing = {
'fixation': 100,
'stimulus': 2000,
'delay': 0,
'decision': 100
}
if timing:
self.timing.update(timing)
# Similar to gym envs, define observations_space and action_space
# Optional annotation of the observation space
name = {'fixation': 0, 'stimulus': [1, 2]}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(3, ),
dtype=np.float32,
name=name)
# Optional annotation of the action space
name = {'fixation': 0, 'choice': [1, 2]}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0):
super().__init__(dt=dt)
self.choices = [0, 1]
# trial conditions
self.pairs = [(1, 3), (1, 4), (2, 3), (2, 4)]
self.association = 0 # GO if np.diff(self.pair)[0]%2==self.association
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Durations (stimulus duration will be drawn from an exponential)
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': -1., 'miss': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 0,
'stim1': 1000,
'delay_btw_stim': 1000,
'stim2': 1000,
'delay_aft_stim': 1000,
'decision': 500
}
if timing:
self.timing.update(timing)
self.abort = False
# action and observation spaces
name = {'fixation': 0, 'stimulus': range(1, 5)}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(5, ),
dtype=np.float32,
name=name)
self.action_space = spaces.Discrete(2, name={'fixation': 0, 'go': 1})
def __init__(self, dt=100, rewards=None, timing=None, dim_ring=16):
super().__init__(dt=dt)
# Rewards
self.rewards = {'correct': +1., 'fail': -0.1}
if rewards:
self.rewards.update(rewards)
self.timing = {'fixation': 500, 'reach': 500}
if timing:
self.timing.update(timing)
# action and observation spaces
name = {
'self': range(dim_ring, 2 * dim_ring),
'target': range(dim_ring)
}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(2 * dim_ring, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'left': 1, 'right': 2}
self.action_space = spaces.Discrete(3, name=name)
self.theta = np.arange(0, 2 * np.pi, 2 * np.pi / dim_ring)
self.state = np.pi
self.dim_ring = dim_ring
def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0,
dim_ring=2):
super().__init__(dt=dt)
self.choices = ['match', 'non-match'] # match, non-match
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'sample': 650,
'first_delay': 1000,
'test': 650}
if timing:
self.timing.update(timing)
self.abort = False
self.theta = np.linspace(0, 2 * np.pi, dim_ring + 1)[:-1]
name = {'fixation': 0, 'stimulus': range(1, dim_ring + 1)}
self.observation_space = spaces.Box(
-np.inf, np.inf, shape=(1 + dim_ring,), dtype=np.float32, name=name)
name = {'fixation': 0, 'match': 1, 'non-match': 2}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self, dt=80, rewards=None, timing=None):
super().__init__(dt=dt)
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 300,
'stim1': lambda: self.rng.uniform(300, 600),
'delay1': lambda: self.rng.uniform(800, 1500),
'stim2': lambda: self.rng.uniform(300, 600),
'delay2': 500,
'decision': 300
}
if timing:
self.timing.update(timing)
self.abort = False
name = {'fixation': 0, 'stim1': 1, 'stim2': 2}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(3, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice1': 1, 'choice2': 2}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self, dt=100, rewards=None, timing=None):
super().__init__(dt=dt)
# Actions (fixate, go)
self.actions = [0, 1]
# trial conditions
self.choices = [0, 1]
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': -0.5, 'miss': -0.5}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 0,
'stimulus': 500,
'delay': 500,
'decision': 500}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation spaces
name = {'fixation': 0, 'nogo': 1, 'go': 2}
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(3,),
dtype=np.float32, name=name)
self.action_space = spaces.Discrete(2, {'fixation': 0, 'go': 1})
def __init__(self, dt=80, rewards=None, timing=None, prod_margin=0.2):
super().__init__(dt=dt)
self.prod_margin = prod_margin
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': ngym.random.TruncExp(400, 100, 800, rng=self.rng),
'target': ngym.random.TruncExp(1000, 500, 1500, rng=self.rng),
's1': 100,
'interval1': (600, 700, 800, 900, 1000),
's2': 100,
'interval2': 0,
's3': 100,
'interval3': 0,
'response': 1000
}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
name = {'fixation': 0, 'stimulus': 1, 'target': 2}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(3, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'go': 1}
self.action_space = spaces.Discrete(2, name=name)
def __init__(self, dt=80, rewards=None, timing=None, prod_margin=0.2):
super().__init__(dt=dt)
self.prod_margin = prod_margin
self.production_ind = [0, 1]
self.intervals = [800, 1500]
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500, # XXX: not specified
'cue': lambda: self.rng.uniform(1000, 3000),
'set': 50
}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
self.action_space = spaces.Discrete(2) # (fixate, go)
# Fixation, Interval indicator x2, Set
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(4, ),
dtype=np.float32)
def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0):
super().__init__(dt=dt)
# trial conditions
self.contexts = [0, 1] # index for context inputs
self.choices = [1, 2] # left, right choice
self.cohs = [5, 15, 50]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 300,
# 'target': 350,
'stimulus': 750,
'delay': ngym.random.TruncExp(600, 300, 3000),
'decision': 100}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
names = ['fixation', 'stim1_mod1', 'stim2_mod1',
'stim1_mod2', 'stim2_mod2', 'context1', 'context2']
name = {name: i for i, name in enumerate(names)}
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(7,),
dtype=np.float32, name=name)
name = {'fixation': 0, 'choice1': 1, 'choice2': 2}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self,
dt=10,
rewards=None,
timing=None,
p_pulse=(0.3, 0.7),
n_bin=6):
super().__init__(dt=dt)
self.p_pulse = p_pulse
self.n_bin = n_bin
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {'fixation': 500, 'decision': 500}
for i in range(n_bin):
self.timing['cue' + str(i)] = 10
self.timing['bin' + str(i)] = 240
if timing:
self.timing.update(timing)
self.abort = False
name = {'fixation': 0, 'stimulus': [1, 2]}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(3, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': [1, 2]}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
sigma=1.,
stim_scale=1.,
n_ch=3,
ob_nch=False,
zero_irrelevant_stim=False,
ob_histblock=False,
cohs=[0, 6.4, 12.8, 25.6, 51.2]):
super().__init__(dt=dt)
self.n = n_ch
self.choices = np.arange(n_ch)
self.ob_nch = ob_nch
self.ob_histblock = ob_histblock
self.zero_irrelevant_stim = zero_irrelevant_stim
assert isinstance(n_ch, int), 'n_ch must be integer'
assert n_ch > 1, 'n_ch must be at least 2'
assert isinstance(ob_histblock, bool), 'ob_histblock \
must be True/False'
assert isinstance(ob_nch, bool), 'ob_nch \
must be True/False'
self.cohs = np.array(cohs) * stim_scale
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'stimulus': ngym.random.TruncExp(330, 80, 1500, rng=self.rng),
'decision': 500
}
if timing:
self.timing.update(timing)
self.abort = False
# Action and observation spaces
name = {'fixation': 0, 'stimulus': range(1, n_ch + 1)}
if ob_nch:
name.update({'Active choices': n_ch + ob_nch})
if ob_histblock:
name.update({'Current block': n_ch + ob_nch + ob_histblock})
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(n_ch + ob_nch +
ob_histblock + 1, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': range(1, n_ch + 1)}
self.action_space = spaces.Discrete(n_ch + 1, name=name)
def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0, cohs=None,
dim_ring=16, w_mod=(1, 1), stim_mod=(True, True),
delaycomparison=True):
super().__init__(dt=dt)
# trial conditions
if cohs is None:
self.cohs = np.array([0.08, 0.16, 0.32])
else:
self.cohs = cohs
self.w_mod1, self.w_mod2 = w_mod
self.stim_mod1, self.stim_mod2 = stim_mod
self.delaycomparison = delaycomparison
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
if self.delaycomparison:
self.timing = {
'fixation': lambda: self.rng.uniform(200, 500),
'stim1': 500,
'delay': 1000,
'stim2': 500,
'decision': 200}
else:
self.timing = {
'fixation': lambda: self.rng.uniform(200, 500),
'stimulus': 500,
'decision': 200}
if timing:
self.timing.update(timing)
self.abort = False
# action and observation space
self.theta = np.linspace(0, 2*np.pi, dim_ring+1)[:-1]
self.choices = np.arange(dim_ring)
if dim_ring < 2:
raise ValueError('dim ring can not be smaller than 2')
name = {
'fixation': 0,
'stimulus_mod1': range(1, dim_ring + 1),
'stimulus_mod2': range(dim_ring + 1, 2 * dim_ring + 1)}
self.observation_space = spaces.Box(
-np.inf, np.inf, shape=(1 + 2 * dim_ring,),
dtype=np.float32, name=name)
name = {'fixation': 0, 'choice': range(1, dim_ring + 1)}
self.action_space = spaces.Discrete(1+dim_ring, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
lowbound=0.,
highbound=1.):
super().__init__(dt=dt)
self.lowbound = lowbound
self.highbound = highbound
# Rewards
self.rewards = {
'abort': -0.1,
'correct': +1.,
'fail': -0.,
'miss': -0.5
}
if rewards:
self.rewards.update(rewards)
self.timing = {
'stimulus': 500,
'delay': (0, 1000, 2000),
'decision': 500
}
if timing:
self.timing.update(timing)
self.r_tmax = self.rewards['miss']
self.abort = False
name = {'go': 0, 'stimulus': 1}
self.observation_space = spaces.Box(low=np.array([0., -2]),
high=np.array([1, 2.]),
dtype=np.float32,
name=name)
self.action_space = spaces.Box(low=np.array((-1.0, -1.0)),
high=np.array((1.0, 2.0)),
dtype=np.float32)
def __init__(self, env, modality=0, n_modality=1):
super().__init__(env)
self.modality = modality
if 'stimulus' not in self.task.observation_space.name:
raise KeyError('observation_space does not have name stimulus')
ind_stimulus = np.array(self.task.observation_space.name['stimulus'])
len_stimulus = len(ind_stimulus)
ob_space = self.task.observation_space
ob_shape = ob_space.shape[0] + (n_modality - 1) * len_stimulus
# Shift stimulus
name = {'stimulus': ind_stimulus + len_stimulus * modality}
self.observation_space = self.task.observation_space = spaces.Box(
-np.inf, np.inf, shape=(ob_shape,), dtype=ob_space.dtype, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
shape_weight=None,
n_loc=4):
super().__init__(dt=dt)
# The evidence weight of each stimulus
if shape_weight is not None:
self.shape_weight = shape_weight
else:
self.shape_weight = [
-10, -0.9, -0.7, -0.5, -0.3, 0.3, 0.5, 0.7, 0.9, 10
]
self.n_shape = len(self.shape_weight)
dim_shape = self.n_shape
# Shape representation needs to be fixed cross-platform
self.shapes = np.eye(self.n_shape, dim_shape)
self.n_loc = n_loc
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'delay': lambda: self.rng.uniform(450, 550),
'decision': 500
}
for i_loc in range(n_loc):
self.timing['stimulus' + str(i_loc)] = 500
if timing:
self.timing.update(timing)
self.abort = False
name = {'fixation': 0}
start = 1
for i_loc in range(n_loc):
name['loc' + str(i_loc)] = range(start, start + dim_shape)
start += dim_shape
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(1 + dim_shape * n_loc, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': [1, 2]}
self.action_space = spaces.Discrete(3, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
sigma=0.1,
stim_scale=1.,
n_ch=10,
n_stims=2):
super().__init__(dt=dt)
self.n_ch = n_ch
self.choices = np.arange(n_stims)
self.stims = np.array(list(itertools.product([0, 1],
repeat=n_ch))).T == 1
self.stims = self.stims[:,
np.random.choice(self.stims.shape[1],
size=n_stims,
replace=False)]
assert isinstance(n_ch, int), 'n_ch must be integer'
assert isinstance(n_stims, int), 'n_stims must be integer'
assert n_stims > 1, 'n_stims must be at least 2'
# The strength of evidence, modulated by stim_scale.
self.cohs = np.array([100.]) * stim_scale
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'stimulus': 500,
'delay': 1000,
'decision': 500
}
if timing:
self.timing.update(timing)
self.abort = False
# Action and observation spaces
name = {'fixation': 0, 'stimulus': range(1, n_ch + 1)}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(n_ch + 1, ),
dtype=np.float32,
name=name)
self.mapping = np.arange(n_stims)
self.unwrapped.rng.shuffle(self.mapping)
name = {'fixation': 0, 'choice': range(1, n_stims + 1)}
self.action_space = spaces.Discrete(n_stims + 1, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
sigma=1.0,
delay=None,
stim_dur=100):
super().__init__(dt=dt)
# Possible decisions at the end of the trial
self.choices = [0, 1]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
self.delay = delay
self.stim_dur = int(stim_dur / self.dt) # in steps should be greater
# than 1 stp else it wont have enough time to respond within the window
if self.stim_dur == 1:
self.extra_step = 1
if delay is None:
warnings.warn('Added an extra stp after the actual stimulus,' +
' else model will not be able to respond ' +
'within response window (stimulus epoch)')
else:
self.extra_step = 0
if self.stim_dur < 1:
warnings.warn('Stimulus duration shorter than dt')
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': -1., 'miss': -1}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'stimulus': ngym.random.TruncExp(1000, 500, 1500)
}
if timing:
self.timing.update(timing)
# whether to abort (T) or not (F) the trial when breaking fixation:
self.abort = False
name = {'fixation': 0, 'stimulus': 1}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(2, ),
dtype=np.float32,
name=name)
self.action_space = spaces.Discrete(2, name={'fixation': 0, 'go': 1})
def __init__(self,
dt=100,
context=0,
rewards=None,
timing=None,
sigma=1.0,
dim_ring=2):
super().__init__(dt=dt)
# trial conditions
self.choices = [1, 2] # left, right choice
self.cohs = [5, 15, 50]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
self.context = context
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 300,
# 'target': 350,
'stimulus': 750,
'delay': ngym.random.TruncExp(600, 300, 3000, rng=self.rng),
'decision': 100
}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
self.theta = np.linspace(0, 2 * np.pi, dim_ring + 1)[:-1]
self.choices = np.arange(dim_ring)
name = {
'fixation': 0,
'stimulus_mod1': range(1, dim_ring + 1),
'stimulus_mod2': range(dim_ring + 1, 2 * dim_ring + 1)
}
shape = (1 + 2 * dim_ring, )
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=shape,
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': range(1, dim_ring + 1)}
self.action_space = spaces.Discrete(1 + dim_ring, name=name)
def __init__(self,
dt=100,
vpairs=None,
rewards=None,
timing=None,
sigma=1.0):
super().__init__(dt=dt)
# Pair of stimulus strengthes
if vpairs is None:
self.vpairs = [(18, 10), (22, 14), (26, 18), (30, 22), (34, 26)]
else:
self.vpairs = vpairs
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 500,
'stimulus1': 500,
'delay': 1000,
'stimulus2': 500,
'decision': 100
}
if timing:
self.timing.update(timing)
self.abort = False
# Input scaling
self.vall = np.ravel(self.vpairs)
self.vmin = np.min(self.vall)
self.vmax = np.max(self.vall)
# action and observation space
name = {'fixation': 0, 'stimulus': 1}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(2, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': [1, 2]}
self.action_space = spaces.Discrete(3, name=name)
self.choices = [1, 2]
def __init__(self, dt=100, rewards=None, timing=None):
super().__init__(dt=dt)
# trial conditions
self.B_to_A = 1 / 2.2
self.juices = [('a', 'b'), ('b', 'a')]
self.offers = [(0, 1), (1, 3), (1, 2), (1, 1), (2, 1), (3, 1), (4, 1),
(6, 1), (2, 0)]
# Rewards
self.rewards = {'abort': -0.1, 'correct': +0.22}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 1500,
'offer_on': lambda: self.rng.uniform(1000, 2000),
'decision': 750
}
if timing:
self.timing.update(timing)
self.R_B = self.B_to_A * self.rewards['correct']
self.R_A = self.rewards['correct']
self.abort = False
# Increase initial policy -> baseline weights
self.baseline_Win = 10
name = {
'fixation': 0,
'a1': 1,
'b1': 2, # a or b for choice 1
'a2': 3,
'b2': 4, # a or b for choice 2
'n1': 5,
'n2': 6 # amount for choice 1 or 2
}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(7, ),
dtype=np.float32,
name=name)
self.act_dict = {'fixation': 0, 'choice1': 1, 'choice2': 2}
self.action_space = spaces.Discrete(3, name=self.act_dict)
def __init__(self, dt=100, n=2, p=(.5, .5), rewards=None, timing=None):
super().__init__(dt=dt)
if timing is not None:
print('Warning: Bandit task does not require timing variable.')
if rewards:
self.rewards = rewards
else:
self.rewards = np.ones(n) # 1 for every arm
self.n = n
self.p = np.array(p) # Reward probabilities
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(1, ),
dtype=np.float32)
self.action_space = spaces.Discrete(n)
def __init__(self, dt=100, rewards=None, timing=None):
super().__init__(dt=dt)
# Rewards
self.rewards = {'correct': +1., 'fail': -0.1}
if rewards:
self.rewards.update(rewards)
self.timing = {'fixation': 500, 'reach': 500}
if timing:
self.timing.update(timing)
# action and observation spaces
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(32, ),
dtype=np.float32)
self.theta = np.arange(0, 2 * np.pi, 2 * np.pi / 32)
self.state = np.pi
def __init__(self,
dt=100,
rewards=None,
timing=None,
dim_ring=2,
sigma=1.0):
super().__init__(dt=dt)
self.wagers = [True, False]
self.theta = np.linspace(0, 2 * np.pi, dim_ring + 1)[:-1]
self.choices = np.arange(dim_ring)
self.cohs = [0, 3.2, 6.4, 12.8, 25.6, 51.2]
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.rewards['sure'] = 0.7 * self.rewards['correct']
self.timing = {
'fixation': 100,
# 'target': 0,
'stimulus': ngym.random.TruncExp(180, 100, 900),
'delay': ngym.random.TruncExp(1350, 1200, 1800),
'pre_sure': lambda: self.rng.uniform(500, 750),
'decision': 100
}
if timing:
self.timing.update(timing)
self.abort = False
# set action and observation space
name = {'fixation': 0, 'stimulus': [1, 2], 'sure': 3}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(4, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': [1, 2], 'sure': 3}
self.action_space = spaces.Discrete(4, name=name)
def __init__(self,
dt=100,
rewards=None,
timing=None,
cohs=None,
sigma=1.0,
dim_ring=2):
super().__init__(dt=dt)
if cohs is None:
self.cohs = np.array([0, 6.4, 12.8, 25.6, 51.2])
else:
self.cohs = cohs
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 100,
'stimulus': 2000,
'delay': 0,
'decision': 100
}
if timing:
self.timing.update(timing)
self.abort = False
self.theta = np.linspace(0, 2 * np.pi, dim_ring + 1)[:-1]
self.choices = np.arange(dim_ring)
name = {'fixation': 0, 'stimulus': range(1, dim_ring + 1)}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(1 + dim_ring, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'choice': range(1, dim_ring + 1)}
self.action_space = spaces.Discrete(1 + dim_ring, name=name)
def __init__(self, dt=100, rewards=None, timing=None, sigma=1.0,
dim_ring=16, matchto='sample', matchgo=True):
super().__init__(dt=dt)
self.matchto = matchto
if self.matchto not in ['sample', 'category']:
raise ValueError('Match has to be either sample or category')
self.matchgo = matchgo
self.choices = ['match', 'non-match'] # match, non-match
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 300,
'sample': 500,
'delay': 1000,
'test': 500,
'decision': 900}
if timing:
self.timing.update(timing)
self.abort = False
if np.mod(dim_ring, 2) != 0:
raise ValueError('dim ring should be an even number')
self.dim_ring = dim_ring
self.half_ring = int(self.dim_ring/2)
self.theta = np.linspace(0, 2 * np.pi, dim_ring + 1)[:-1]
name = {'fixation': 0, 'stimulus': range(1, dim_ring + 1)}
self.observation_space = spaces.Box(
-np.inf, np.inf, shape=(1 + dim_ring,), dtype=np.float32, name=name)
name = {'fixation': 0, 'choice': range(1, dim_ring + 1)}
self.action_space = spaces.Discrete(1+dim_ring, name=name)
def __init__(self, dt=100, rewards=None, timing=None):
super().__init__(dt=dt)
self.choices = [0, 1]
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': ngym.random.TruncExp(600, 400, 800, rng=self.rng),
'rule_target': 1000,
'fixation2': ngym.random.TruncExp(600, 400, 900, rng=self.rng),
'flash1': 100,
'delay': (530, 610, 690, 770, 850, 930, 1010, 1090, 1170),
'flash2': 100,
'decision': 700,
}
if timing:
self.timing.update(timing)
self.mid_delay = np.median(self.timing['delay'][1])
self.abort = False
name = {'fixation': 0, 'rule': [1, 2], 'stimulus': [3, 4]}
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(5, ),
dtype=np.float32,
name=name)
name = {'fixation': 0, 'rule': [1, 2], 'choice': [3, 4]}
self.action_space = spaces.Discrete(5, name=name)
self.chose_correct_rule = False
self.rule = 0
self.trial_in_block = 0
self.block_size = 10
self.new_block()
def __init__(self,
dt=100,
rewards=None,
timing=None,
stim_scale=1.,
sigma=1.0):
super().__init__(dt=dt)
self.choices = [1, 2]
# cohs specifies the amount of evidence (modulated by stim_scale)
self.cohs = np.array([0, 6.4, 12.8, 25.6, 51.2]) * stim_scale
self.sigma = sigma / np.sqrt(self.dt) # Input noise
# Rewards
self.rewards = {'abort': -0.1, 'correct': +1., 'fail': 0.}
if rewards:
self.rewards.update(rewards)
self.timing = {
'fixation': 0,
'stimulus': 1150,
# TODO: sampling of delays follows exponential
'delay': (300, 500, 700, 900, 1200, 2000, 3200, 4000),
# 'go_cue': 100, # TODO: Not implemented
'decision': 1500
}
if timing:
self.timing.update(timing)
self.abort = False
# action and observation spaces
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(3, ),
dtype=np.float32)
