def devalois1982b_properties(model_identifier, responses, baseline):
_assert_grating_activations(responses)
radius = np.array(sorted(set(responses.radius.values)))
spatial_frequency = np.array(
sorted(set(responses.spatial_frequency.values)))
orientation = np.array(sorted(set(responses.orientation.values)))
phase = np.array(sorted(set(responses.phase.values)))
responses = responses.values
baseline = baseline.values
assert responses.shape[0] == baseline.shape[0]
n_neuroids = responses.shape[0]
responses = responses.reshape(
(n_neuroids, len(radius), len(spatial_frequency), len(orientation),
len(phase)))
responses_dc = responses.mean(axis=4) - baseline.reshape((-1, 1, 1, 1))
responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
responses_ac = responses_ac[:, :, :, :, 1] * 2
responses = np.zeros(
(n_neuroids, len(radius), len(spatial_frequency), len(orientation), 2))
responses[:, :, :, :, 0] = responses_dc
responses[:, :, :, :, 1] = responses_ac
del responses_ac, responses_dc
max_response = responses.reshape((n_neuroids, -1)).max(axis=1,
keepdims=True)
peak_spatial_frequency = np.zeros((n_neuroids, 1))
for neur in range(n_neuroids):
pref_radius, pref_spatial_frequency, pref_orientation, pref_component = \
np.unravel_index(np.argmax(responses[neur, :, :, :, :]),
(len(radius), len(spatial_frequency), len(orientation), 2))
spatial_frequency_curve = responses[neur, pref_radius, :,
pref_orientation, pref_component]
peak_spatial_frequency[neur] = \
calc_spatial_frequency_tuning(spatial_frequency_curve, spatial_frequency, thrsh=0.707, filt_type='smooth',
mode='ratio')[1]
properties_data = peak_spatial_frequency
good_neuroids = max_response > RESPONSE_THRESHOLD
properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
properties_data = DataAssembly(
properties_data,
coords={
'neuroid_id': ('neuroid', range(properties_data.shape[0])),
'region': ('neuroid', ['V1'] * properties_data.shape[0]),
'neuronal_property': PROPERTY_NAMES
},
dims=['neuroid', 'neuronal_property'])
return properties_data
def schiller1976_properties(model_identifier, responses, baseline):
_assert_grating_activations(responses)
radius = np.array(sorted(set(responses.radius.values)))
spatial_frequency = np.array(
sorted(set(responses.spatial_frequency.values)))
orientation = np.array(sorted(set(responses.orientation.values)))
phase = np.array(sorted(set(responses.phase.values)))
responses = responses.values
baseline = baseline.values
assert responses.shape[0] == baseline.shape[0]
n_neuroids = responses.shape[0]
responses = responses.reshape(
(n_neuroids, len(radius), len(spatial_frequency), len(orientation),
len(phase)))
responses = responses.mean(axis=4)
max_response = responses.reshape((n_neuroids, -1)).max(axis=1,
keepdims=True)
spatial_frequency_bandwidth = np.zeros((n_neuroids, 1))
spatial_frequency_selective = np.ones((n_neuroids, 1))
for neur in range(n_neuroids):
pref_radius, pref_spatial_frequency, pref_orientation = \
np.unravel_index(np.argmax(responses[neur, :, :, :]),
(len(radius), len(spatial_frequency), len(orientation)))
spatial_frequency_curve = responses[neur, pref_radius, :,
pref_orientation]
spatial_frequency_bandwidth[neur] = \
calc_spatial_frequency_tuning(spatial_frequency_curve, spatial_frequency, thrsh=0.707, filt_type='smooth',
mode='ratio')[0]
spatial_frequency_selective[np.isnan(spatial_frequency_bandwidth)] = 0
properties_data = np.concatenate(
(spatial_frequency_selective, spatial_frequency_bandwidth), axis=1)
good_neuroids = max_response > baseline + RESPONSE_THRESHOLD
properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
properties_data = DataAssembly(
properties_data,
coords={
'neuroid_id': ('neuroid', range(properties_data.shape[0])),
'region': ('neuroid', ['V1'] * properties_data.shape[0]),
'neuronal_property': PROPERTY_NAMES
},
dims=['neuroid', 'neuronal_property'])
return properties_data
def devalois1982a_properties(model_identifier, responses, baseline):
_assert_grating_activations(responses)
spatial_frequency = np.array(
sorted(set(responses.spatial_frequency.values)))
orientation = np.array(sorted(set(responses.orientation.values)))
phase = np.array(sorted(set(responses.phase.values)))
nStim = responses.values.shape[1]
n_cycles = nStim // (len(phase) * len(orientation) *
len(spatial_frequency))
responses = responses.values
baseline = baseline.values
assert responses.shape[0] == baseline.shape[0]
n_neuroids = responses.shape[0]
responses = responses.reshape(
(n_neuroids, n_cycles, len(spatial_frequency), len(orientation),
len(phase)))
responses = responses.mean(axis=4)
preferred_orientation = np.zeros((n_neuroids, 1))
max_response = responses.reshape((n_neuroids, -1)).max(axis=1,
keepdims=True)
for neur in range(n_neuroids):
pref_cycle, pref_spatial_frequency, pref_orientation = np.unravel_index(
np.argmax(responses[neur]),
(n_cycles, len(spatial_frequency), len(orientation)))
orientation_curve = responses[neur, pref_cycle,
pref_spatial_frequency, :]
preferred_orientation[neur] = \
calc_bandwidth(orientation_curve, orientation, filt_type='smooth', thrsh=0.5, mode='full')[1]
preferred_orientation[preferred_orientation >= ORIENTATION_BIN_LIM] = \
preferred_orientation[preferred_orientation >= ORIENTATION_BIN_LIM] - 180
properties_data = preferred_orientation
good_neuroids = max_response > baseline + RESPONSE_THRESHOLD
properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
properties_data = DataAssembly(
properties_data,
coords={
'neuroid_id': ('neuroid', range(properties_data.shape[0])),
'region': ('neuroid', ['V1'] * properties_data.shape[0]),
'neuronal_property': PROPERTY_NAMES
},
dims=['neuroid', 'neuronal_property'])
return properties_data
def ringach2002_properties(model_identifier, responses, baseline):
_assert_grating_activations(responses)
spatial_frequency = np.array(
sorted(set(responses.spatial_frequency.values)))
orientation = np.array(sorted(set(responses.orientation.values)))
phase = np.array(sorted(set(responses.phase.values)))
nStim = responses.values.shape[1]
n_cycles = nStim // (len(phase) * len(orientation) *
len(spatial_frequency))
responses = responses.values
baseline = baseline.values
assert responses.shape[0] == baseline.shape[0]
n_neuroids = responses.shape[0]
responses = responses.reshape(
(n_neuroids, n_cycles, len(spatial_frequency), len(orientation),
len(phase)))
responses_dc = responses.mean(axis=4)
responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
responses_ac = responses_ac[:, :, :, :, 1] * 2
del responses
max_dc = np.zeros((n_neuroids, 1))
max_ac = np.zeros((n_neuroids, 1))
min_dc = np.zeros((n_neuroids, 1))
circular_variance = np.zeros((n_neuroids, 1))
bandwidth = np.zeros((n_neuroids, 1))
orthogonal_preferred_ratio = np.zeros((n_neuroids, 1))
orientation_selective = np.ones((n_neuroids, 1))
for neur in range(n_neuroids):
pref_cycle, pref_spatial_frequency, pref_orientation = np.unravel_index(
np.argmax(responses_dc[neur]),
(n_cycles, len(spatial_frequency), len(orientation)))
max_dc[neur] = responses_dc[neur, pref_cycle, pref_spatial_frequency,
pref_orientation]
max_ac[neur] = responses_ac[neur, pref_cycle, pref_spatial_frequency,
pref_orientation]
orientation_curve = responses_dc[neur, pref_cycle,
pref_spatial_frequency, :]
min_dc[neur] = orientation_curve.min()
circular_variance[neur] = calc_circular_variance(
orientation_curve, orientation)
bandwidth[neur] = \
calc_bandwidth(orientation_curve, orientation, filt_type='hanning', thrsh=0.707, mode='half')[0]
orthogonal_preferred_ratio[neur] = calc_orthogonal_preferred_ratio(
orientation_curve, orientation)
orientation_selective[np.isnan(bandwidth)] = 0
modulation_ratio = max_ac / max_dc
circular_variance_bandwidth_ratio = circular_variance / bandwidth
orthogonal_preferred_ratio_circular_variance_difference = orthogonal_preferred_ratio - circular_variance
orthogonal_preferred_ratio_bandwidth_ratio = orthogonal_preferred_ratio / bandwidth
properties_data = np.concatenate(
(baseline, max_dc, min_dc, max_ac, modulation_ratio, circular_variance,
bandwidth, orthogonal_preferred_ratio, orientation_selective,
circular_variance_bandwidth_ratio,
orthogonal_preferred_ratio_circular_variance_difference,
orthogonal_preferred_ratio_bandwidth_ratio),
axis=1)
good_neuroids = max_dc > baseline + RESPONSE_THRESHOLD
properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
properties_data = DataAssembly(
properties_data,
coords={
'neuroid_id': ('neuroid', range(properties_data.shape[0])),
'region': ('neuroid', ['V1'] * properties_data.shape[0]),
'neuronal_property': PROPERTY_NAMES
},
dims=['neuroid', 'neuronal_property'])
return properties_data
def cavanaugh2002_properties(model_identifier, responses, baseline):
_assert_grating_activations(responses)
radius = np.array(sorted(set(responses.radius.values)))
spatial_frequency = np.array(
sorted(set(responses.spatial_frequency.values)))
orientation = np.array(sorted(set(responses.orientation.values)))
phase = np.array(sorted(set(responses.phase.values)))
responses = responses.values
baseline = baseline.values
assert responses.shape[0] == baseline.shape[0]
n_neuroids = responses.shape[0]
responses = responses.reshape(
(n_neuroids, len(radius), len(spatial_frequency), len(orientation),
len(phase)))
responses_dc = responses.mean(axis=4) - baseline.reshape((-1, 1, 1, 1))
responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
responses_ac = responses_ac[:, :, :, :, 1] * 2
responses = np.zeros(
(n_neuroids, len(radius), len(spatial_frequency), len(orientation), 2))
responses[:, :, :, :, 0] = responses_dc
responses[:, :, :, :, 1] = responses_ac
del responses_ac, responses_dc
max_response = responses.reshape((n_neuroids, -1)).max(axis=1,
keepdims=True)
surround_suppression_index = np.zeros((n_neuroids, 1))
strongly_suppressed = np.zeros((n_neuroids, 1))
grating_summation_field = np.zeros((n_neuroids, 1))
surround_diameter = np.zeros((n_neuroids, 1))
surround_grating_summation_field_ratio = np.zeros((n_neuroids, 1))
for neur in range(n_neuroids):
pref_radius, pref_spatial_frequency, pref_orientation, pref_component = \
np.unravel_index(np.argmax(responses[neur, :, :, :, :]),
(len(radius), len(spatial_frequency), len(orientation), 2))
size_curve = responses[neur, :, pref_spatial_frequency,
pref_orientation, pref_component]
grating_summation_field[neur], surround_diameter[neur], surround_grating_summation_field_ratio[neur], \
surround_suppression_index[neur] = calc_size_tuning(size_curve, radius)
strongly_suppressed[surround_suppression_index >= 0.1] = 1
properties_data = np.concatenate(
(surround_suppression_index, strongly_suppressed,
grating_summation_field, surround_diameter,
surround_grating_summation_field_ratio),
axis=1)
good_neuroids = max_response > RESPONSE_THRESHOLD
properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
properties_data = DataAssembly(
properties_data,
coords={
'neuroid_id': ('neuroid', range(properties_data.shape[0])),
'region': ('neuroid', ['V1'] * properties_data.shape[0]),
'neuronal_property': PROPERTY_NAMES
},
dims=['neuroid', 'neuronal_property'])
return properties_data
