neurotools.stats package

Submodules

• neurotools.stats.circular module
  • logpolar_gaussian()
  • complex_gaussian()
  • logpolar_stats()
  • abspolar_stats()
  • squared_first_circular_moment()
  • fit_vonmises()
  • wrapped_circular_linear_error()
  • asunit()
  • circvar()
  • circwrap()
  • circmce()
  • circdelta()
  • circmean()
  • circcenter()
  • circcorr()
  • circabsdelta()
  • degrees_to_survey_format()
• neurotools.stats.covalign module
  • keeprank()
  • expected_intersection_rank1()
  • expected_intersection()
  • expected_intersection_enormed()
  • expected_intersection_enormed_chance()
  • rebuild_unit_quality_caches()
  • orthnormedcovariance()
  • get_orthogonal_alignment()
  • alignment_angle()
  • sample_alignment_angle()
  • sample_alignment_self()
  • sample_alignment_cross()
  • sample_alignment_complement()
  • alignment_angle_unnormalized()
  • alignment_angle_normalized()
  • sample_alignment_angle_unnormalized()
  • sample_alignment_angle_normalized()
  • sample_alignment_self_unnormalized()
  • sample_alignment_self_unnormalized_nounit()
  • sample_alignment_self_normalized()
  • sample_alignment_cross_normalized()
  • sample_alignment_complement_normalized()
  • new_alignment_normalized()
• neurotools.stats.density module
  • kdepeak()
  • knn_1d_density()
  • adaptive_density_grid()
  • gridhist()
• neurotools.stats.distributions module
  • poisson_logpdf()
  • poisson_pdf()
  • gaussian_logpdf()
  • gaussian_pdf()
  • explogpdf()
  • sample_categorical()
• neurotools.stats.fastkde module
  • fast_kde()
  • image_cov()
• neurotools.stats.gaussian module
  • gaussian_quadrature()
  • gaussian_quadrature_logarithmic()
  • Gaussian
    • Gaussian.m
    • Gaussian.t
    • Gaussian.logpdf()
  • MVG_check()
  • MVG_logPDF()
  • MVG_PDF()
  • MVG_sample()
  • MVG_multiply()
  • MVG_multiply_C()
  • MVG_divide()
  • MVG_projection()
  • MVG_entropy()
  • MVG_DKL()
  • MVG_DKL_CP()
  • MVG_conditional()
  • MVG_kalman()
  • MVG_kalman_P_inverseA()
  • MVG_kalman_joint()
  • MVG_kalman_joint_P()
• neurotools.stats.glm module
  • GLMPenaltyPoisson()
  • sexp()
  • sigmoid()
  • GLMPenaltyBernoulli()
  • GLMPenaltyL2()
  • ppglmfit()
  • fitGLM()
  • crossvalidatedAUC()
  • gradientglmfit()
  • cosine_kernel()
  • log_cosine_basis()
  • make_cosine_basis()
  • numeric_grad()
  • numeric_hess()
• neurotools.stats.gridsearch module
  • grid_search()
• neurotools.stats.hmm module
  • poisson_parameter_guess()
  • poisson_baum_welch()
  • viterbi()
  • viterbi_log()
  • hasNaN()
  • poisson_viterbi_state_infer()
  • forward_backward()
  • jump()
  • sample()
  • log_likelihood()
  • baum_welch()
  • forward_abstract()
  • backward_abstract()
  • forward_backward_abstract()
  • DiffusionGaussian
    • DiffusionGaussian.fwd()
    • DiffusionGaussian.bwd()
  • LogGaussianCoxApproximator
  • LogGaussianCoxModel
  • GaussianCoxApproximator
  • GaussianCoxModel
  • ChisquareCoxApproximator
  • ChisquareCoxModel
  • BernoulliObservationApproximator
  • BernoulliObservationModel
  • TruncatedLogGaussianCoxApproximator
  • TruncatedLogGaussianCoxModel
  • MVGaussian
  • MVGUpdate
    • MVGUpdate.fwd()
    • MVGUpdate.bwd()
  • lgcp_observation_minimizer()
  • MVLogGaussianCox
    • MVLogGaussianCox.MVPoissonApproximator
  • OUGaussian
    • OUGaussian.fwd()
    • OUGaussian.bwd()
  • MVGOUUpdate
    • MVGOUUpdate.fwd()
    • MVGOUUpdate.bwd()
  • PoissonObservationApproximator
  • PoissonObservationModel
  • TruncatedPoissonObservationApproximator
  • TruncatedPoissonObservationModel
• neurotools.stats.information module
  • discrete
    • discrete.DKL()
    • discrete.H()
    • discrete.H_samples()
    • discrete.Hcond()
    • discrete.I()
    • discrete.shuffle()
    • discrete.Ishuff()
    • discrete.deltaIshuff()
    • discrete.deltaI()
    • discrete.deltaInoise()
    • discrete.deltaIsig()
    • discrete.syn()
    • discrete.syn2()
  • poisson_entropy_nats()
  • betapr()
  • beta_regularized_histogram_mutual_information()
  • JointCategoricalDistribution
    • JointCategoricalDistribution.counts
    • JointCategoricalDistribution.joined
    • JointCategoricalDistribution.kept
    • JointCategoricalDistribution.states
    • JointCategoricalDistribution.nstate
  • joint()
  • dirichlet_density
    • dirichlet_density.joint_model()
    • dirichlet_density.p()
    • dirichlet_density.lnp()
    • dirichlet_density.plnp()
    • dirichlet_density.H()
    • dirichlet_density.I()
    • dirichlet_density.redundancy()
    • dirichlet_density.foo()
• neurotools.stats.kalman module
  • multiply_gaussian()
  • kalman_forward()
  • kalman_backward()
  • kalman_measure()
  • kalman_smooth()
• neurotools.stats.mcint module
  • monte_carlo_expectation()
  • monte_carlo_moments()
• neurotools.stats.minimize module
  • FailureError
  • minimize_retry()
• neurotools.stats.mixtures module
  • two_class_poisson_mixture_model()
• neurotools.stats.modefind module
  • modefind()
  • logmodeplot()
  • logmode()
  • peakfinder5()
• neurotools.stats.pvalues module
  • benjamini_hochberg_positive_correlations()
  • correct_pvalues_positive_dependent()
  • correct_pvalues()
  • bootstrap_statistic()
  • bootstrap_statistic_two_sided()
  • bootstrap_median()
  • bootstrap_mean()
  • bootstrap_compare_statistic_two_sided()
  • bootstrap_compare_statistic_two_sided_parallel()
  • bootstrap_compare_median()
  • bootstrap_compare_mean()
  • bootstrap_in_blocks()
  • nancorrect()
  • atac()
• neurotools.stats.regressions module
  • damped_cosine()
  • weighted_least_squares()
  • power_law()
  • gaussian_function()
  • half_gaussian_function()
  • exponential_decay()
  • robust_line()
  • cubic_spline_regression()
  • CircregressResult
    • CircregressResult.get_theta_samples()
    • CircregressResult.get_d2_samples()
    • CircregressResult.get_R2_samples()
  • circregress()
• neurotools.stats.shuffleL2explore module
  • hess()
  • MSE()
  • error_covariance()
  • reglstq_moments()
  • reglstsq_MSE()
  • regroup()
  • ungroup()
  • scov()
  • xy_moments()
  • reglstq_xy()
  • group_moments()
  • group_mse()
  • group_error_covariance()
  • get_whiten()
  • group_R2_matrix()
  • regsweep_r2()
  • regsweep_MSE()
  • shuffle_variable()
  • adaptive_shuffle()
  • AdaptiveShuffleResult
    • AdaptiveShuffleResult.pvalue
    • AdaptiveShuffleResult.k
    • AdaptiveShuffleResult.n
    • AdaptiveShuffleResult.vunique
    • AdaptiveShuffleResult.r2
    • AdaptiveShuffleResult.eta
    • AdaptiveShuffleResult.allr2
  • adaptive_shuffle_pvalue()
  • joint_reglstsq_MSE()
  • best_rho()
  • joint_best_rho_gradient()
  • lfit()
  • leave_one_out()
  • linear_regression_shuffle()
  • beta()
  • binomial()
  • bytes()
  • chisquare()
  • choice()
  • dirichlet()
  • exponential()
  • f()
  • gamma()
  • geometric()
  • get_state()
  • gumbel()
  • hypergeometric()
  • laplace()
  • logistic()
  • lognormal()
  • logseries()
  • multinomial()
  • multivariate_normal()
  • negative_binomial()
  • noncentral_chisquare()
  • noncentral_f()
  • normal()
  • pareto()
  • permutation()
  • poisson()
  • power()
  • rand()
  • randint()
  • randn()
  • random()
  • random_integers()
  • random_sample()
  • rayleigh()
  • set_state()
  • shuffle()
  • standard_cauchy()
  • standard_exponential()
  • standard_gamma()
  • standard_normal()
  • standard_t()
  • triangular()
  • uniform()
  • vonmises()
  • wald()
  • weibull()
  • zipf()
• neurotools.stats.tests module
  • two_tailed_sampled_test()
  • ZTestResult
    • ZTestResult.z
    • ZTestResult.pvalue
  • ztest_from_moments()
  • WeightedTtestResult
    • WeightedTtestResult.t
    • WeightedTtestResult.pvalue
    • WeightedTtestResult.dof
    • WeightedTtestResult.alternative
    • WeightedTtestResult.sem
    • WeightedTtestResult.mu
    • WeightedTtestResult.s
  • weighted_ttest_1samp()
  • beta_propotion_test()
  • cohen_d()

Module contents

Statistical routines.

neurotools.stats.partition_data(x, y, NFOLD=3)

Parrition independent variables x and dependent variables y into NFOLD crossvalidation training/testing datasets.

Parameters:

• x (Ncovariates × Nsamples np.array) – Independent variables

• y (Npredicted × Nsamples np.array) – Dependent variables

• NFOLD (int; default 3) – Number of crossvalidation blocks to partition data into.

Returns:

result –

Iterator with NFOLD items, each element yielding:

xtrain: training data for x for this block ytrain: training data for y for this block xtest: testing data for x for this block ytest: testing data for y for this block

Return type:

iterator

neurotools.stats.partition_trials_for_crossvalidation(x, K, shuffle=False)

Split trial data into crossvalidation blocks.

Parameters:

• x (list) – List of trial data to partition. Each entry in the list should be a NTIMEPOITS×NVARIABLES array.

• K (int) – Number of crossvalidation blocks to compute

• shuffle (bool, default False)

Returns:

spans – List of trial indecies to use for each block

Return type:

list

neurotools.stats.add_constant(data, axis=None)

Appends a constant feature to a multi-dimensional array of dependent variables.

Parameters:

• data (np.array)

• axis (int or (default) None) – Axis along which to append the constant feature

neurotools.stats.trial_crossvalidated_least_squares(a, b, K, regress=None, reg=1e-10, shuffle=False, errmethod='L2', **kwargs)

predicts B from A in K-fold cross-validated blocks using linear least squares. I.e. find w such that B=Aw.

Parameters:

• a (array) – List of trials for independent variables; For every trial, the first dimension should be time or number of samples, etc.

• b (vector) – List of trials for dependent variables

• K (int) – Number of cross-validation blocks

• regress (function, optional) – Regression function, defaults to np.linalg.lstsq (if providing another function, please match the call signature of np.linalg.lstsq)

• reg (scalar, default 1e-10) – L2 regularization penalty

• shuffle (bool, default False) – Whether to shuffle trials before crossvalidation

• errmethod (String) – Method used to compute the error. Can be ‘L1’ (mean absolute error); ‘L2’ (root mean-squared error) or ‘correlation’ (pearson correlation coefficient).

• add_constant (bool, default False) – Whether to append an additional constand offset feature to the data. The returned weight matrix will have one extra entry, at the end, reflecting the offset, if this is set to True.

Returns:

• w, array-like – model coefficients x from each cross-validation

• bhat, array-like – predicted values of b under crossvalidation

• error – root mean squared error from each crossvalidation

neurotools.stats.partition_data_for_crossvalidation(a, b, K, discard_mean=False)

For predicting B from A, partition both training and testing data into K-fold cross-validation blocks. This operates over the first axis of the array

Parameters:

• a (array) – Independent variables; First dimension should be time or number of samples, etc.

• b (vector) – dependent variables

• K (int) – Number of cross-validation blocks

• discard_mean (boolean; default False) – Whether to remove the means from all variables.

Returns:

• trainA (list) – list of training blocks for independent variables A

• trainB (list) – list of training blocks for dependent variables B

• testA (list) – list of testing blocks for independent variables A

• testB (list) – list of testing blocks for dependent variables B

neurotools.stats.block_shuffle(x, blocksize=None)

Shuffle a 2D array in blocks along axis 0 For example, if you provide a NTIMES × NFEATURES array, this will shuffle all features similarly in blocks along the time axis.

Parameters:

• x (np.array) – First dimension should be time or samples; This dimension will be shuffled in blocks of size blocksize.

• blocksize (int or (default) None) – If None, defaults to max(10,x.shape[0]//100) i.e. chooses a size to divide x into 100 blocks.

Returns:

result

Return type:

np.array

neurotools.stats.crossvalidated_least_squares(a, b, K, regress=None, reg=1e-10, blockshuffle=None)

predicts B from A in K-fold cross-validated blocks using linear least squares. I.e. find w such that B = Aw

Parameters:

• a (array) – Independent variables; First dimension should be time or number of samples, etc.

• b (vector) – dependent variables

• K (int) – Number of cross-validation blocks

• regress (function, optional) – Regression function, defaults to np.linalg.lstsq (if providing another function, please match the call signature of np.linalg.lstsq)

• reg (scalar, default 1e-10) – L2 regularization penalty

• blockshuffle (positive int or None, default None) – If not None, should be a positive integeter indicating the block-size in which to shuffle the input data before breaking it into cross-validation blocks.

Returns:

• w, array-like – model coefficients x from each cross-validation

• bhat, array-like – predicted values of b under crossvalidation

• cc, number – correlation coefficient

• rms, number – root mean squared error

neurotools.stats.fraction_explained_deviance(L, L0, Ls)

Calculate the fraction explained deviance, which is the analogue of the linear-Gaussian r² for Generalized Linear Models (GLMs)

Parameters:

• L (np.float32) – Model likelihood(s) evaluated on held-out test data.

• L0 (np.float32) – Baseline likelihood, calculated by using the test-data’s mean-rate as a prediction.

• Ls (np.float32) – Saturated model likelihood(s) calculated by using the true labels as the estimated values

Returns:

r² – normalized explained deviance

Return type:

np.array

neurotools.stats.nrmse(estimate, true, axis=None)

Normalized root mean-squared error.

Parameters:

• estimate (array-like) – Estimated data values

• true (array-like) – True data values

• axis (int; default None) – Array axis along which to operate.

Returns:

result – Root-mean-squared error between estiamte and true, normalized by the variance of true.

Return type:

np.float64

neurotools.stats.weighted_avg_and_std(values, weights)

Return the weighted average and standard deviation. values, weights – Numpy ndarrays with the same shape.

Parameters:

• values (np.array) – Array of values for which to compute (μ,σ) weighted summary statistics

• weights (np.array) – Weights for each value

Returns:

• mean (np.float64) – Weighted mean

• sigma (np.float64) – Weighted standard deviation

neurotools.stats.print_stats(g, name='', prefix='')

computes, prints, and returns mean, median, minimum, and maximum.

Parameters:

g (1D np.array) – List of samples

Returns:

• mean (np.array)

• median (np.array)

• minimum (np.array)

• maximum (np.array)

neurotools.stats.outliers(x, percent=10, side='both')

Reject outliers from data based on percentiles.

Parameters:

• x (ndarary) – 1D numeric array of data values

• percent (number) – percent between 0 and 100 to remove

• side (str) – ‘left’ ‘right’ or ‘both’. Default is ‘both’. Remove extreme values from the left / right / both sides of the data distribution. If both, the percent is halved and removed from both the left and the right

Returns:

Boolean array of same shape as x indicating outliers

Return type:

np.bool

neurotools.stats.reject_outliers(x, percent=10, side='both')

Reject outliers from data based on percentiles.

Parameters:

• x (ndarary) – 1D numeric array of data values

• percent (number) – percent between 0 and 100 to remove

• side (str) – ‘left’ ‘right’ or ‘both’. Default is ‘both’. Remove extreme values from the left / right / both sides of the data distribution. If both, the percent is halved and removed from both the left and the right.

Returns:

• np.ndarray – Values with outliers removed

• kept (np.int32) – Indecies of values kept

• removed (np.int32) – Indecies of values removed

class neurotools.stats.Description(data)

Bases: object

quick statistical description

short()

Abbreviated statistical summary

neurotools.stats.glmfit(X, Y)

Wrapper for statsmodels glmfit that prepares a constant parameter and configuration options for poisson-GLM fitting. Please see the documentation for glmfit in statsmodels for more details.

This method will automatically add a constant colum to the feature matrix Y.

Parameters:

• X (array-like) – A NOBSERVATIONS × K array where NOBSERVATIONS is the number of observations and k is the number of regressors. An intercept is not included by default and should be added by the user (models specified using a formula include an intercept by default). See statsmodels.tools.add_constant.

• Y (array-like) – 1d array of poisson counts. This array can be 1d or 2d.

neurotools.stats.pca(x, n_keep=None, rank_deficient=False)

w,v = pca(x,n_keep=None) Performs PCA on data x, keeping the first `n_keep ` dimensions

Parameters:

• x (ndarray) – NSAMPLES×NFEATURES array on which to perform PCA

• n_keep (int) – Number of principle components to retain

Returns:

• w (weights (eigenvalues))

• v (eigenvector (principal components))

neurotools.stats.covariance(x, y=None, sample_deficient=False, reg=0.0, centered=True)

Covariance matrix for Nsamples x Nfeatures matrix. Data are not centered before computing covariance.

Parameters:

• x (NSAMPLES×NFEATURES array-like) – Array of input features

• y (Nsamples x Nyfeatures array-like) – Array of input features

• sample_deficient (bool, default False) – Whether the data contains fewer samples than it does features. If False (the default), routine will raise a ValueError.

• reg (positive scalar, default 0) – Diagonal regularization to add to the covariance

• centered (boolean, default True) – Whether to subtract the means from the data before taking the covariace.

Returns:

C – Sample covariance matrix

Return type:

np.array

neurotools.stats.get_factor_analysis(X, NFACTORS)

Wrapper to fit factor analysis model, extract the model, and sort by factor importance.

Parameters:

• X (np.array) – Multivariate signal

• NFACTORS (int) – Number of factors to fit

Returns:

• Y – Result of fa.fit_transform(X)

• Sigma – fa.noise_variance_

• F – fa.components_

• lmbda – Loadings diag(F.dot(F.T))

• fa (sklearn.decomposition.FactorAnalysis) – Fitted factor analysis model

neurotools.stats.project_factors(X, F, S)

Project observations X with noise variances S onto latent factors F. This uses the same argument/return conventions as scipy’s factor analysis.

Parameters:

• X (array-like) – data

• F (array-like) – factor matrix

• S (array-like) – i.i.d variances

neurotools.stats.predict_latent(fa, predict_from, X)

Predict mean of all factors from predict_from factors.

Parameters:

• fa (sklearn.decomposition.FactorAnalysis) – Fitted factor analysis model

• predict_from (list of int) – Factor indecies to use for prediction

• X (np.array) – Underlying signal

Returns:

Xthat – Predicted means over time

Return type:

np.array

neurotools.stats.factor_predict(fa, predict_from, predict_to, X)

Predict mean, variance of predict_to factors from predict_from factors.

Parameters:

• fa (sklearn.decomposition.FactorAnalysis) – Fitted factor analysis model

• predict_from (list of int) – Factor indecies to use for prediction

• predict_to (list of int) – Factor indecies to predict

• X (np.array) – Underlying signal

Returns:

• Xthat (np.array) – Predicted means over time

• Xtc (np.array) – Predicted covariance over time

neurotools.stats.nanrankdata(x, mode='fraction')

A variant of rankdata that handles NaNs better. Returns normalized rank in (0,1) by default.

Parameters:

• x (iterable) – Data to be ranked

• mode (str; default 'fraction') – 'fraction': return rank of non-NaN values in (0,1) 'percentile': return rank of non-NaN values in (0,100) None: return integer ranks (NaNs excluded)

neurotools.stats.mean_confidence_interval(data, confidence=0.95)

neurotools.stats.minmax(x)