def test_get_stimulus_table(detailed, just_stimulus_table_api, raw_stimulus_table): session = EcephysSession(api=just_stimulus_table_api) obtained = session.get_stimulus_table(['a'], include_detailed_parameters=detailed) expected_columns = [ 'start_time', 'stop_time', 'stimulus_name', 'stimulus_block', 'Color', 'Phase' ] if detailed: expected_columns.append("texRes") expected = raw_stimulus_table.loc[:2, expected_columns] expected['duration'] = expected['stop_time'] - expected['start_time'] expected["stimulus_condition_id"] = [0, 1, 2] expected.rename(columns={"Color": "color", "Phase": "phase"}, inplace=True) print(expected) print(obtained) pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_conditionwise_spike_statistics_using_rates(spike_times_api): session = EcephysSession(api=spike_times_api) obtained = session.conditionwise_spike_statistics( stimulus_presentation_ids=[0, 1, 2], use_rates=True) pd.set_option('display.max_columns', None) assert np.allclose([0, 0, 6], obtained["spike_mean"].values)
def test_conditionwise_spike_statistics(spike_times_api): session = EcephysSession(api=spike_times_api) obtained = session.conditionwise_spike_statistics(stimulus_presentation_ids=[0, 1, 2]) pd.set_option('display.max_columns', None) assert obtained.loc[(2, 2), "spike_count"] == 3 assert obtained.loc[(2, 2), "stimulus_presentation_count"] == 1
def test_empty_presentationwise_spike_times(spike_times_api): # Test that when there are no spikes presentationwise_spike_times doesn't fail and instead returns a empty dataframe spike_times_api.get_spike_times = types.MethodType(get_no_spikes_times, spike_times_api) session = EcephysSession(api=spike_times_api) obtained = session.presentationwise_spike_times(session.stimulus_presentations.index.values, session.units.index.values) assert(isinstance(obtained, pd.DataFrame)) assert(obtained.empty)
def test_get_invalid_times(valid_stimulus_table_api, raw_invalid_times_table): expected = raw_invalid_times_table session = EcephysSession(api=valid_stimulus_table_api) obtained = session.get_invalid_times() pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_get_stimulus_parameter_values(just_stimulus_table_api): session = EcephysSession(api=just_stimulus_table_api) obtained = session.get_stimulus_parameter_values() expected = {'color': [0, 5.5, 11, 16.5], 'phase': [0, 60, 120, 180]} for k, v in expected.items(): assert np.allclose(v, obtained[k]) assert len(expected) == len(obtained)
def test_get_lfp(channels_table_api): session = EcephysSession(api=channels_table_api) obtained = session.get_lfp(0) expected = xr.DataArray(data=np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]), dims=['channel', 'time'], coords=[[2, 1], np.linspace(0, 2, 5)]) xr.testing.assert_equal(expected, obtained)
def test_presentationwise_spike_times(spike_times_api): session = EcephysSession(api=spike_times_api) obtained = session.presentationwise_spike_times(session.stimulus_presentations.index.values, session.units.index.values) expected = pd.DataFrame({ 'unit_id': [2, 2, 2], 'stimulus_presentation_id': [2, 2, 2, ], 'time_since_stimulus_presentation_onset': [0.01, 0.02, 0.03] }, index=pd.Index(name='spike_time', data=[1.01, 1.02, 1.03])) pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_presentationwise_spike_counts(spike_times_api): session = EcephysSession(api=spike_times_api) obtained = session.presentationwise_spike_counts(np.linspace(-.1, .1, 3), session.stimulus_presentations.index.values, session.units.index.values) first = obtained.loc[{'unit_id': 2, 'stimulus_presentation_id': 2}] assert np.allclose([0, 3], first) second = obtained.loc[{'unit_id': 1, 'stimulus_presentation_id': 3}] assert np.allclose([0, 0], second) assert np.allclose([4, 2, 3], obtained.shape)
def test_get_lfp_mask_invalid(lfp_masking_api): session = EcephysSession(api=lfp_masking_api) obtained = session.get_lfp(0) expected = xr.DataArray(data=np.array([[1, 2, 3, np.nan, np.nan], [6, 7, 8, np.nan, np.nan]]), dims=['channel', 'time'], coords=[[2, 1], np.linspace(0, 2, 5)]) print(expected) print(obtained) xr.testing.assert_equal(expected, obtained)
def test_empty_conditionwise_spike_statistics(spike_times_api): # special case when there are no spikes spike_times_api.get_spike_times = types.MethodType(get_no_spikes_times, spike_times_api) session = EcephysSession(api=spike_times_api) obtained = session.conditionwise_spike_statistics( stimulus_presentation_ids=session.stimulus_presentations.index.values, unit_ids=session.units.index.values ) assert(len(obtained) == 12) assert(not np.any(obtained['spike_count'])) # check all spike_counts are 0 assert(not np.any(obtained['spike_mean'])) # spike_means are 0 assert(np.all(np.isnan(obtained['spike_std']))) # std/sem will be undefined assert(np.all(np.isnan(obtained['spike_sem'])))
def test_get_inter_presentation_intervals_for_stimulus(just_stimulus_table_api): session = EcephysSession(api=just_stimulus_table_api) obtained = session.get_inter_presentation_intervals_for_stimulus('a') expected = pd.DataFrame({ 'interval': [0, 0] }, index=pd.MultiIndex( levels=[[0, 1], [1, 2]], codes=[[0, 1], [0, 1]], names=['from_presentation_id', 'to_presentation_id'] ) ) pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_build_units_table(units_table_api): session = EcephysSession(api=units_table_api) obtained = session.units assert 3 == session.num_units assert np.allclose([10, 22, 33], obtained['probe_vertical_position']) assert np.allclose([0, 1, 2], obtained.index.values)
def load_session_and_get_fr_df(self): session = EcephysSession.from_nwb_path(self.nwb_path, api_kwargs={ "amplitude_cutoff_maximum": 0.1, "presence_ratio_minimum": 0.9, "isi_violations_maximum": 0.5 }) self.units_df = session.units self.stim_table = session.get_stimulus_table(self.stim_name) stim_pres_ids = self.stim_table.index.values tmp_binned_spt = session.presentationwise_spike_counts\ (bin_edges = self.bin_edges, stimulus_presentation_ids=stim_pres_ids, unit_ids = session.units.index.values) num_pres, num_bins, num_cells = tmp_binned_spt.shape print(num_pres, num_bins, num_cells) tot_arr_fr_all = np.reshape(tmp_binned_spt.values, (num_pres * num_bins, num_cells)) self.tot_fr_df = pd.DataFrame(tot_arr_fr_all.T, index=session.units.index.values) del tmp_binned_spt, session
def test_metrics(ecephys_api): session = EcephysSession(api=ecephys_api) rfm = ReceptiveFieldMapping(ecephys_session=session, minimum_spike_count=1.0, trial_duration=0.25, mask_threshold=0.5) assert (isinstance(rfm.metrics, pd.DataFrame)) assert (len(rfm.metrics) == 6) assert (rfm.metrics.index.names == ['unit_id']) # TODO: Methods are too sensitive and will have different values depending on the version of scipy assert ('azimuth_rf' in rfm.metrics.columns) assert ('elevation_rf' in rfm.metrics.columns) assert ('width_rf' in rfm.metrics.columns) assert ('height_rf' in rfm.metrics.columns) # Different versions of scipy will return unit 1 as either a 0.0 or a nan #assert(np.allclose(rfm.metrics['height_rf'].loc[[0, 1, 2, 3, 4, 5]], # [np.nan, 0.0, 129.522395, np.nan, np.nan, np.nan], equal_nan=True)) assert ('area_rf' in rfm.metrics.columns) assert (np.allclose(rfm.metrics['area_rf'].loc[[0, 1, 2, 3, 4, 5]], [0.0, 0.0, 0.0, np.nan, 0.0, 0.0], equal_nan=True)) assert ('p_value_rf' in rfm.metrics.columns) assert ('on_screen_rf' in rfm.metrics.columns) assert ('firing_rate_rf' in rfm.metrics.columns) assert ('fano_rf' in rfm.metrics.columns) assert ('time_to_peak_rf' in rfm.metrics.columns) assert ('lifetime_sparseness_rf' in rfm.metrics.columns) assert ('run_pval_rf' in rfm.metrics.columns) assert ('run_mod_rf' in rfm.metrics.columns)
def test_receptive_fields(ecephys_api): # Also test_response_by_stimulus_position() session = EcephysSession(api=ecephys_api) rfm = ReceptiveFieldMapping(ecephys_session=session) assert (rfm.receptive_fields) assert (type(rfm.receptive_fields)) assert ('spike_counts' in rfm.receptive_fields) assert (rfm.receptive_fields['spike_counts'].shape == (9, 9, 6) ) # x, y, units assert (set(rfm.receptive_fields['spike_counts'].coords) == { 'y_position', 'x_position', 'unit_id' }) assert (np.all(rfm.receptive_fields['spike_counts'].coords['x_position'] == [-40.0, -30.0, -20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0])) assert (np.all(rfm.receptive_fields['spike_counts'].coords['y_position'] == [0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0])) # Some randomly sampled testing to make sure everything works like it should assert (rfm.receptive_fields['spike_counts'][{ 'unit_id': 0 }].values.sum() == 4) assert (rfm.receptive_fields['spike_counts'][{ 'unit_id': 3 }].values.sum() == 0) assert (rfm.receptive_fields['spike_counts'][{ 'unit_id': 2, 'x_position': 8, 'y_position': 3 }] == 3) assert (np.all(rfm.receptive_fields['spike_counts'][{ 'x_position': 2, 'y_position': 5 }] == [1, 0, 0, 0, 1, 1]))
def test_bad_col_key(ecephys_api): with pytest.raises(KeyError): session = EcephysSession(api=ecephys_api) sg = StaticGratings(ecephys_session=session, col_sf='spatial_frequency', col_phase='esahp') sg.phasevals
def test_metrics(ecephys_api): session = EcephysSession(api=ecephys_api) sg = StaticGratings(ecephys_session=session) assert (isinstance(sg.metrics, pd.DataFrame)) assert (len(sg.metrics) == 6) assert (sg.metrics.index.names == ['unit_id']) assert ('pref_sf_sg' in sg.metrics.columns) assert (np.all( sg.metrics['pref_sf_sg'].loc[[0, 2, 4]] == [0.02, 0.02, 0.04])) assert ('pref_ori_sg' in sg.metrics.columns) assert (np.all( sg.metrics['pref_ori_sg'].loc[[0, 2, 4]] == [0.0, 0.0, 0.0])) assert ('pref_phase_sg' in sg.metrics.columns) assert (np.all(sg.metrics['pref_phase_sg'].loc[[0, 1, 2, 3]] == [0.25, 0.75, 0.5, 0.0])) assert ('g_osi_sg' in sg.metrics.columns) assert ('time_to_peak_sg' in sg.metrics.columns) assert ('firing_rate_sg' in sg.metrics.columns) assert ('fano_sg' in sg.metrics.columns) assert ('lifetime_sparseness_sg' in sg.metrics.columns) assert ('run_pval_sg' in sg.metrics.columns) assert ('run_mod_sg' in sg.metrics.columns)
def test_conditionwise_psth(ecephys_api): session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0', trial_duration=0.5, psth_resolution=0.1) assert (isinstance(stim_analysis.conditionwise_psth, xr.DataArray)) # assert(stim_analysis.conditionwise_psth.shape == (2, 4, 6)) assert (stim_analysis.conditionwise_psth. coords['time_relative_to_stimulus_onset'].size == 4) # 0.5/0.1 - 1 assert (stim_analysis.conditionwise_psth.coords['unit_id'].size == 6) assert (stim_analysis.conditionwise_psth.coords['stimulus_condition_id']. size == 2) assert (np.allclose( stim_analysis.conditionwise_psth[{ 'unit_id': 0, 'stimulus_condition_id': 1 }].values, np.array([1.0 / 3.0, 0.0, 0.0, 0.0]))) # Make sure psth doesn't fail even when all the condition_ids are unique. stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s1', trial_duration=0.5, psth_resolution=0.1) assert (stim_analysis.conditionwise_psth. coords['time_relative_to_stimulus_onset'].size == 4) assert (stim_analysis.conditionwise_psth.coords['unit_id'].size == 6) assert (stim_analysis.conditionwise_psth.coords['stimulus_condition_id']. size == 2)
def test_get_time_to_peak(ecephys_api): session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0', trial_duration=0.5) assert (stim_analysis._get_time_to_peak( 1, stim_analysis._get_preferred_condition(1)) == 0.0005)
def test_get_preferred_condition(ecephys_api): session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0') assert (stim_analysis._get_preferred_condition(3) == 1) with pytest.raises(KeyError): stim_analysis._get_preferred_condition(10)
def test_spikes(ecephys_api): session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0') assert (isinstance(stim_analysis.spikes, dict)) assert (stim_analysis.spikes.keys() == set(range(6))) assert (np.allclose(stim_analysis.spikes[0], [1, 2, 3, 4])) assert (np.allclose(stim_analysis.spikes[4], [0.01, 1.7, 2.13, 3.19, 4.25])) assert (stim_analysis.spikes[3].size == 0) # Check that spikes dict is filtering units session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0', filter=[0, 2]) assert (stim_analysis.spikes.keys() == {0, 2})
def test_contrast_stimulus(ecephys_api_w_contrast): session = EcephysSession(api=ecephys_api_w_contrast) dg = DriftingGratings(ecephys_session=session) assert (len(dg.stim_table) == 40) assert (len(dg.stim_table_contrast) == 36) assert (len(dg.stimulus_conditions_contrast) == 36) assert (len(dg.conditionwise_statistics_contrast) == 36 * 6)
def test_get_stimulus_epochs(just_stimulus_table_api): expected = pd.DataFrame({ "start_time": [0, 3/2], "stop_time": [3/2, 2], "duration": [3/2, 1/2], "stimulus_name": ["a", "a_movie"], "stimulus_block": [0, 1] }) session = EcephysSession(api=just_stimulus_table_api) obtained = session.get_stimulus_epochs() print(expected) print(obtained) pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_check_multiple_preferred_conditions(ecephys_api): session = EcephysSession(api=ecephys_api) stim_analysis = StimulusAnalysis(ecephys_session=session, stimulus_key='s0') assert (stim_analysis._check_multiple_pref_conditions( 0, 'conditions', [0, 1]) is False) assert (stim_analysis._check_multiple_pref_conditions( 3, 'conditions', [0, 1]) is True)
def test_stimulus(ecephys_api): session = EcephysSession(api=ecephys_api) fl = Flashes(ecephys_session=session) assert (isinstance(fl.stim_table, pd.DataFrame)) assert (len(fl.stim_table) == 16) assert (set(fl.stim_table.columns).issuperset( {'color', 'start_time', 'stop_time'})) assert (all(fl.colors == [-1.0, 1.0])) assert (fl.number_colors == 2)
def test_load(ecephys_api): session = EcephysSession(api=ecephys_api) fl = Flashes(ecephys_session=session) assert (fl.name == 'Flashes') assert (set(fl.unit_ids) == set(range(6))) assert (len(fl.conditionwise_statistics) == 2 * 6) assert (fl.conditionwise_psth.shape == (2, 249, 6)) assert (not fl.presentationwise_spike_times.empty) assert (len(fl.presentationwise_statistics) == 16 * 6) assert (len(fl.stimulus_conditions) == 2)
def test_load(ecephys_api): session = EcephysSession(api=ecephys_api) rfm = ReceptiveFieldMapping(ecephys_session=session) assert (rfm.name == 'Receptive Field Mapping') assert (set(rfm.unit_ids) == set(range(6))) assert (len(rfm.conditionwise_statistics) == 81 * 6) assert (rfm.conditionwise_psth.shape == (81, 249, 6)) assert (not rfm.presentationwise_spike_times.empty) assert (len(rfm.presentationwise_statistics) == 81 * 6) assert (len(rfm.stimulus_conditions) == 81)
def test_load(ecephys_api): session = EcephysSession(api=ecephys_api) sg = StaticGratings(ecephys_session=session) assert (sg.name == 'Static Gratings') assert (set(sg.unit_ids) == set(range(6))) assert (len(sg.conditionwise_statistics) == 120 * 6) assert (sg.conditionwise_psth.shape == (120, 249, 6)) assert (not sg.presentationwise_spike_times.empty) assert (len(sg.presentationwise_statistics) == 120 * 6) assert (len(sg.stimulus_conditions) == 120)
def test_load(ecephys_api): session = EcephysSession(api=ecephys_api) ns = NaturalScenes(ecephys_session=session) assert (ns.name == 'Natural Scenes') assert (set(ns.unit_ids) == set(range(6))) assert (len(ns.conditionwise_statistics) == 119 * 6) assert (ns.conditionwise_psth.shape == (119, 249, 6)) assert (not ns.presentationwise_spike_times.empty) assert (len(ns.presentationwise_statistics) == 119 * 6) assert (len(ns.stimulus_conditions) == 119)