# %% Testing single stimulus generation
params_single_stim_nonfixed = dict(
frequency=frequency,
number_of_neurons=number_of_neurons,
stimulus_duration=stimulus_duration
)
params_single_stim_fixed = dict(
frequency=frequency,
number_of_neurons=number_of_neurons,
stimulus_duration=stimulus_duration,
exact_frequency=True
)
single_stim_fixed = make_stimulus(**params_single_stim_fixed)
single_stim_nonfixed = make_stimulus(**params_single_stim_nonfixed)
# %% Testing stimuliset generation
params_forward_shift = dict(
stimulus_duration=stimulus_duration,
max_temporal_shift=5,
num_transformed=num_transformed
)
params_symmetric_interval = dict(
stimulus_duration=stimulus_duration,
interval=(1, 3),
num_transformed=num_transformed
)
params_fixed_release = dict(
release_duration=release_duration,
number_of_vesicles=number_of_vesicles,
stimuli_set2 = make_set_from_specs(
**creation_params,
set_size=200,
set_transform_function=set_transform_function,
set_transform_params=set_transform_params,
origin_transform_function=origin_transform_function,
origin_transform_params=origin_transform_params)
s2a = stimuli_set2.stimuli[stimuli_set2.labels == 0]
s2b = stimuli_set2.stimuli[stimuli_set2.labels == 1]
d2 = np.array([
calc_stimuli_distance(
a, b, stimulus_duration=creation_params['stimulus_duration'])
for a, b in zip(s2a, s2b)
])
stim_a = make_stimulus(**creation_params)
stim_b = make_stimulus(**creation_params)
stimuli_set3 = make_set_from_stimuli(
(stim_a, stim_b),
stimulus_duration=creation_params['stimulus_duration'],
set_size=200,
set_transform_function=set_transform_function,
set_transform_params=set_transform_params)
s3a = stimuli_set3.stimuli[stimuli_set3.labels == 0]
s3b = stimuli_set3.stimuli[stimuli_set3.labels == 1]
d3 = np.array([
calc_stimuli_distance(
a, b, stimulus_duration=creation_params['stimulus_duration'])
for a, b in zip(s3a, s3b)
])
def make_set_from_specs(frequency: float, number_of_neurons: int, stimulus_duration: float, set_size: int,
set_transform_function: Callable, set_transform_params: dict,
origin_transform_function: Callable = None, origin_transform_params: dict = None,
exact_frequency: bool = False, shuffle_set_order: bool = True) -> StimuliSet:
"""
This function accepts specifications for stimulus creation,
creates two stimuli with these specifications,
and then applies the set_transform_function with set_transform_params to each
stimulus, collecting the transformed versions of both stimuli into the stimuli_set.
if origin_transform_function AND origin_transform_params are specified,
One original stimulus will be generated with the desired specs,
whereas the other will be generated by applying origin_transform_function with origin_transform_params
to that same stimulus.
:param frequency: The average firing frequency of each neuron in the sample, units: Hz
:param number_of_neurons: Number of neurons in the stimulus, units: Integer
:param stimulus_duration: Maximal stimulus_duration of the stimuli, units: ms
:param set_size: number of stimuli in the final set, an equal number is generated from each original stimulus
:param set_transform_function: A transformation from generation.transform to be applied to the original stimuli
:param set_transform_params: The parameters to be used with set_transformation_function
:param origin_transform_function: A transformation from generation.transform to be applied to one original stimulus in order to generate the other
:param origin_transform_params: The parameters to be used with origin_transform_function
:param exact_frequency: whether all neurons fire with the same exact frequency, or the same average frequency
:param shuffle_set_order: Whether to return the set shuffled or ordered by original stimulus
:return stimuli_set: A StimuliSet object with the following fields:
stimuli - A collection of stimuli in the following format:
Normal: A numpy object array where each item is a stimulus as an array of
neurons and their respective event times
labels - Label for each stimulus in the set according to its origin
(from one of two possible original stimuli)
original_stimuli - tuple containing both original stimuli as numpy arrays of neurons and their
corresponding event times (spikes or vesicle releases)
original_stimuli_distance - The average spike-distance metric between neurons in the two stimuli
converted - Wheter the stimuli are converted or not, in this case False (the format is Normal)
stimulus_duration - copy of the stimulus stimulus_duration above
"""
# Creating at least one original stimulus
original_stimulus_a = make_stimulus(frequency=frequency, number_of_neurons=number_of_neurons,
stimulus_duration=stimulus_duration, exact_frequency=exact_frequency)
# Either creating a stimulus by applying origin_transform_function to original_stimulus_a, or creating an entirely
# New original_stimulus_b
if origin_transform_function and origin_transform_params: # Check if both parameters required for transformation were supplied
# Create original_stimulus_b by transforming original_stimulus_a
original_stimulus_b = origin_transform_function(stimulus=original_stimulus_a, **origin_transform_params)
else:
original_stimulus_b = make_stimulus(frequency=frequency, number_of_neurons=number_of_neurons,
stimulus_duration=stimulus_duration, exact_frequency=exact_frequency)
# Calculate distance between original stimuliW
distance_between_originals = calc_stimuli_distance(stimulus_a=original_stimulus_a,
stimulus_b=original_stimulus_b,
stimulus_duration=stimulus_duration)
# Determine how many transformed version to create from original_stimulus_a and original_stimulus_b
num_transformed = int(set_size / 2)
set_transform_params['num_transformed'] = num_transformed # Add to parameter dictionary
# Create transformed versions from both stimuli
transformed_set_from_a = set_transform_function(stimulus=original_stimulus_a, **set_transform_params)
transformed_set_from_b = set_transform_function(stimulus=original_stimulus_b, **set_transform_params)
# Packing transformed sets as StimuliSet objects for downstream use
transformed_set_from_a = StimuliSet(stimuli=transformed_set_from_a,
labels=[*[0] * num_transformed],
stimulus_duration=stimulus_duration)
transformed_set_from_b = StimuliSet(stimuli=transformed_set_from_b,
labels=[*[1] * num_transformed],
stimulus_duration=stimulus_duration)
# Combine, label and also shuffle (or not)
stimuli_set = set_tools.combine_sets(transformed_from_a=transformed_set_from_a,
transformed_from_b=transformed_set_from_b,
shuffle=shuffle_set_order)
# Package as StimuliSet type along with original stimuli and their respective distance calculated using averaged spike-distance
stimuli_set = StimuliSet(
stimuli=stimuli_set.stimuli,
labels=stimuli_set.labels,
original_stimuli=(original_stimulus_a, original_stimulus_b),
original_stimuli_distance=distance_between_originals,
stimulus_duration=stimulus_duration
)
# Handle returning of original stimuli
return stimuli_set
import numpy as np
# %%
frequencies = [15, 50, 100]
test_stimuli = {
'exact': {freq: []
for freq in frequencies},
'average': {freq: []
for freq in frequencies}
}
num_neurons = 50
num_stimuli = 10
duration = .500
for freq in frequencies:
for i in range(num_stimuli):
test_stimuli['average'][freq].append(
make_stimulus(freq, num_neurons, .5))
test_stimuli['exact'][freq].append(
make_stimulus(freq, num_neurons, .5, exact_frequency=True))
# %%
def test_forward_shift():
shifts = [5, 10, 50, 100]
num_shifted = 30
for shift in shifts:
for stimulus_type, all_freqs in test_stimuli.items():
for frequency, stimuli in all_freqs.items():
for stimulus in stimuli:
# Generate shifted samples in current condition
shifted = forward_shift(stimulus,
duration,
from generation import make_stimulus
from generation.transform import fixed_release, stochastic_release
from itertools import product
import numpy as np
# %%
frequencies = [15, 50, 100]
test_stimuli = {'exact': {freq: [] for freq in frequencies},
'average': {freq: [] for freq in frequencies}}
num_neurons = 50
num_stimuli = 10
duration = 500
for freq in frequencies:
for i in range(num_stimuli):
test_stimuli['average'][freq].append(
make_stimulus(freq, num_neurons, duration)
)
test_stimuli['exact'][freq].append(
make_stimulus(freq, num_neurons, duration, exact_frequency=True)
)
# %%
def test_stochastic_release():
durations = [3, 5, 7, 9, 12]
ves_nums = [5, 20, 100]
rel_probs = [0.1, 0.25, 0.5, 0.75, 1]
rel_conditions = product(durations, ves_nums, rel_probs)
for (release_duration, num_ves, rel_prob) in rel_conditions:
for stimulus_type, all_freqs in test_stimuli.items():
for frequency, stimuli in all_freqs.items():
for stimulus in stimuli:
transformed = stochastic_release(stimulus, duration, release_duration, num_ves, rel_prob, 10)
# %%
print(f'Creating stimuli with {num_neur} neurons - - started: {start_time}')
current_folder = os.path.join(target_folder, current_date, 'source_pairs',
f'{num_neur}_neurons')
check_folder(current_folder)
for freq in frequencies:
print(f'\tNow working on stimuli of {freq}Hz')
for interval in temporal_shift_intervals:
print(f'\t\tCreating stimuli pairs by shifting ±{interval}ms')
# Creating placeholders for all stimuli in current condition
orig_stimuli = []
shifted_stimuli = []
distances = []
for i in range(number_of_pairs):
# Generate original stimulus
orig_stimulus = make_stimulus(frequency=freq, number_of_neurons=num_neur, stimulus_duration=duration)
# Generate shifted stimulus
shifted_stimulus = symmetric_interval_shift(stimulus=orig_stimulus, stimulus_duration=duration,
interval=interval, num_transformed=1)
# Calculate distance metric between two stimuli for reference
distance = calc_stimuli_distance(stimulus_a=orig_stimulus,
stimulus_b=shifted_stimulus,
stimulus_duration=duration)
# Append data to placeholder lists
orig_stimuli.append(orig_stimulus)
shifted_stimuli.append(shifted_stimulus)
distances.append(distance)
# Create structured numpy array of all stimuli in current condition
pairs = np.array(np.zeros(number_of_pairs),
dtype={'names': ('stimulus_a', 'stimulus_b', 'distance'),
'formats': (object, object, float)})