Pitch Temporal Receptive Field Analysis

Documentation related to analyses to determine whether neural activity encodes relative pitch or absolute pitch.

intonatang.pitch_trf.get_bin_edges_abs_rel(timit_pitch, bins=10, percent=95, pitch_scaling='log')

Returns abs_bin_edges and rel_bin_edges

intonatang.pitch_trf.get_nt_nchans_for_out(out, timit_pitch)

Returns number of time points and channels for one subject

out is returned from timit.load_h5py_out(subject_number) and contains TIMIT data for one subject.

This function goes through each TIMIT trial to determine how many timepoints of data are there.

intonatang.pitch_trf.get_stim_and_resp_from_pitch_intensity_neural_activity_fold(pitch_intensity, neural_activity, last_indexes, abs_bin_edges, rel_bin_edges, abs_change_bin_edges=None, nbins=10, feat='all')

Returns matrices for independent variables (stimulus features) and dependent variables (neural activity on all channels) for training, hyperparamater optimization, and testing.

This function further processes the output of get_neural_activity_and_pitch_phonetic_for_fold. Starting with the nt x n_continuous_features matrix of pitch_intensity and the n_chans x nt matrix of neural activity, this function produces the matrices representing the binary matrix of binned pitch features as the stim and transposes the neural activity to get the resp. These are then split into three matrices along the time dimension.

intonatang.pitch_trf.load_timit_shuffled(fold=0)

Loads a shuffled version of timit_pitch which was created and saved by randomize_timit_pitch_contours

intonatang.pitch_trf.load_timit_strat(fold=0)

Loads an ordering of TIMIT sentences so that cross-validation of models will be done with stratification.

Each of the 25 stratified orderings was generated using code that is available in a Notebook.

intonatang.pitch_trf.run_ptrf_analysis_pipeline_for_subject_number(subject_number, pitch_scaling='log')

Pitch temporal receptive field analysis pipeline.

The ptrf pipeline consists of:

  1. Loading TIMIT data for each subject.

  2. For each of the 25 stratified folds for cross validation:
    • Discretize the pitch features (parameterized from f0 values in Hz in timit.save_timit_pitch) into bins.
    • Run ridge regression between stimulus features (pitch bins, and other features like intensity to statistically control for) and neural activity on each electrode.

  3. Save R2 values and weights (which are the temporal receptive fields)

Code for fitting temporal receptive models using Ridge (L2 regularized) regression.

Given two ndarrays, stim and resp, there are two ways to fit trfs in terms of the cross validation strategy. Both CV strategies split the data into three mutually exclusive sets, training, validation (ridge), and test. The regression weights are fit to the training data. The best ridge parameter is found by testing on the ridge set. The final model performance (correlation between actual and predicted response) is calculated from the test set.

The two strategies are:

  1. Simple KFold: run_cv_temporal_ridge_regression_model

    The total samples of the data are split into a (K-1)/K train set, 1/2K ridge set, and 1/2K test set K times.

  2. User-defined: run_cv_temporal_ridge_regression_model_fold

    Use this function when you want to specify your own train, ridge, and test sets (e.g. I use this to make sure training sets have TIMIT sentences with low-to-high pitch variability so that I don’t end up with a training set that is only low pitch variability or only high pitch variability)

intonatang.temporal_receptive_field.get_alphas(start=2, stop=7, num=10)

Returns alphas from num^start to num^stop in log space.

intonatang.temporal_receptive_field.get_delays(delay_seconds=0.4, fs=100)

Returns 1d array of delays for a given window (in s). Default sampling frequency (fs) is 100Hz.

intonatang.temporal_receptive_field.run_cv_temporal_ridge_regression_model_fold(stims, resps, delays=array([ 0, 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]), alphas=array([ 1.00000000e+02, 3.59381366e+02, 1.29154967e+03, 4.64158883e+03, 1.66810054e+04, 5.99484250e+04, 2.15443469e+05, 7.74263683e+05, 2.78255940e+06, 1.00000000e+07]))

Fit trf models with user-given split of data into training, validation, and test.

Parameters:
  • stims (list) – list of stim data split into training, validation, and test i.e. [train_stim, ridge_stim, test_stim] where train_stim is (n_training_samples x n_features)
  • resps (list) – list of resp data split into training, validation, and test. The number of samples in each set should match that for the stims.
Returns:

(tuple)
  • test_corr (ndarray): Correlation between predicted and actual responses on

    test set using wts computed for alpha with best performance on validation set. Shape of test_corr is (n_chans)

  • wts (ndarray): Computed regression weights using best alpha from testing on

    validation set. Shape of wts is (n_chans, n_features)
intonatang.temporal_receptive_field.get_dstim(stim, delays=array([ 0, 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]), add_edges=True)

Returns stimulus features with given delays.

Parameters:
  • stim – (n_samples, n_features)
  • delays – list of delays to use, values in delays have units of indices for stim.
  • add_edges – adds 3 additional delays to both sides of the delays list to account for edge effects in temporal receptive fields.
Returns:

dstim – (n_samples, n_features x n_delays (including edge delays if added))
Return type:

ndarray
intonatang.temporal_receptive_field.run_cv_temporal_ridge_regression_model(stim, resp, delays=array([ 0, 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]), alphas=array([ 1.00000000e+02, 3.59381366e+02, 1.29154967e+03, 4.64158883e+03, 1.66810054e+04, 5.99484250e+04, 2.15443469e+05, 7.74263683e+05, 2.78255940e+06, 1.00000000e+07]), n_folds=5)

Given stim and resp, fit temporal receptive fields using ridge regression and KFold cross validation.

Parameters:
  • stim – (n_samples, n_features)
  • resp – (n_samples, n_chans)
  • delays – (n_delays)
  • alphas – (n_alphas)
  • n_folds (int) – number of folds to use for KFold cross validation. The 1/K fraction of data usually used for the test set is split in half for the ridge parameter validation set and the test set.
Returns:

(tuple)
  • test_corr_folds (ndarray): Correlation between predicted and actual responses on

    test set using wts computed for alpha with best performance on validation set. Shape of test_corr_folds is (n_folds, n_chans)

  • wts_folds (ndarray): Computed regression weights. Shape of wts_folds is

    (n_folds, n_features, n_chans)
intonatang.temporal_receptive_field.run_ridge_regression(train_stim, train_resp, ridge_stim, ridge_resp, alphas)

Runs ridge (L2 regularized) regression for ridge parameters in alphas and returns wts fit on training data and correlation between actual and predicted on validation data for each alpha.

Parameters:
  • train_stim – (n_training_samples x n_features)
  • train_resp – (n_training_samples x n_chans)
  • ridge_stim – (n_validation_samples x n_features)
  • ridge_resp – (n_validation_samples x n_chans)
  • alphas – 1d array with ridge parameters to use
Returns:

  • wts (ndarray): Computed regression weights. Shape of wts is

    (n_alphas, n_features, n_chans)

  • ridge_corrs (ndarray): Correlation between predicted and actual responses on

    ridge validation set. Shape of ridge_corrs is (n_alphas, n_chans)
Return type:

(tuple)

For multiple regression with stim X and resp y and wts B:

  1. XB = y
  2. X’XB = X’y
  3. B = (X’X)^-1 X’y

Add L2 (Ridge) regularization:

  1. B = (X’X + aI)^-1 X’y

Because covariance X’X is a real symmetric matrix, we can decompose it to QLQ’, where Q is an orthogonal matrix with the eigenvectors and L is a diagonal matrix with the eigenvalues of X’X. Furthermore, (QLQ’)^-1 = QL^-1Q’

  1. B = (QLQ’ + aI)^-1 X’y
  2. B = Q (L + aI)^-1 Q’X’y

Variables in code below:

  • covmat is X’X
  • l contains the diagonal entries of L
  • Q is Q
  • Usr is Q’X’y
  • D_inv is (L + aI)^-1

The wts (B) can be calculated by the matrix multiplication of [Q, D_inv, Usr]