def test_nPerFtr2n(): da = xr.DataArray(1.5 * np.ones((2, 3, 4)), dims=('px', 'r', 'Sigma_id'), coords=dict(px=[1, 2])) py = xr.DataArray(2 * np.ones((2, 3, 4)), dims=('px', 'r', 'Sigma_id'), coords=dict(px=[1, 2])).astype(int) assert_raises(NotImplementedError, nPerFtr2n, da.sel(px=1), py) n_req = nPerFtr2n(da, py) assert n_req.name == 'n_required' assert (n_req.dims == np.array(['ptot', 'r', 'Sigma_id'])).all() assert np.allclose(n_req.sel(ptot=3).values, 3 * 1.5) assert np.allclose(n_req.sel(ptot=4).values, 4 * 1.5) ### da['py'] = py n_req_2 = nPerFtr2n( da ) # n_req_2 should be identical to n_req except that it has an additional attribute py del n_req_2['py'] assert_xr_allclose(n_req, n_req_2)
def test_scores_pairwise_spearmansim_stats(): np.random.seed(0) scores = np.array([[.1, .2], [1, 2]]) ds = xr.Dataset(dict( x_test_scores=xr.DataArray(scores, dims=('rep', 'test_sample')), y_test_scores=xr.DataArray(scores, dims=('rep', 'test_sample')), )) scores_pairwise_spearmansim_stats(ds, qs=(.025, .5, .975)) stats_true = xr.DataArray(np.ones(4), dims=('stat',), coords=dict(stat=['q2.5%', 'q50.0%', 'q97.5%', 'mean'])) assert_xr_allclose(ds.x_scores_pairwise_spearmansim_stats, stats_true) assert_xr_allclose(ds.y_scores_pairwise_spearmansim_stats, stats_true)
def test_weights_pairwise_cossim_stats(): np.random.seed(0) weights = np.linalg.qr(np.random.normal(size=(3, 3)))[0] ds = xr.Dataset(dict( x_weights=xr.DataArray(weights, dims=('rep', 'x_feature')), y_weights=xr.DataArray(weights, dims=('rep', 'y_feature')), )) weights_pairwise_cossim_stats(ds, qs=(.025, .5, .975)) stats_true = xr.DataArray(np.zeros(4), dims=('stat',), coords=dict(stat=['q2.5%', 'q50.0%', 'q97.5%', 'mean'])) assert_xr_allclose(ds.x_weights_pairwise_cossim_stats, stats_true) assert_xr_allclose(ds.y_weights_pairwise_cossim_stats, stats_true)
def test_power(): ds = xr.Dataset(dict( between_assocs=xr.DataArray(np.linspace(0, 1, 10).reshape(1, -1), dims=('dummy', 'rep')), between_assocs_perm=xr.DataArray(.05 * np.ones((1, 10, 100)), dims=('dummy', 'rep', 'perm')), )) alpha = 0.05 power(ds, alpha=alpha) p_values = np.array([1] + [.01]*9) true_power = xr.DataArray( np.array([(p_values < alpha).mean()]), dims=('dummy',) ) assert_xr_allclose(ds.power, true_power)
def assert_qty_allclose(a, b, check_attrs=True, **kwargs): from xarray import DataArray from xarray.testing import assert_allclose as assert_xr_allclose from .reporting.utils import Quantity, AttrSeries a = Quantity(a) b = Quantity(b) # check type-specific allclose if Quantity is AttrSeries: # we may assert_series_equal(a, b, **kwargs) elif Quantity is DataArray: assert_xr_allclose(a, b, **kwargs) # check attributes are equal if check_attrs: assert a.attrs == b.attrs
def assert_qty_allclose(a, b, check_attrs=True, **kwargs): """Assert that Quantity objects *a* and *b* have numerically close values. When Quantity is AttrSeries, *a* and *b* are first passed through :meth:`as_quantity`. """ from xarray import DataArray from xarray.testing import assert_allclose as assert_xr_allclose from .reporting.quantity import AttrSeries, Quantity, as_quantity if Quantity is AttrSeries: # Convert pd.Series automatically a = as_quantity(a) if isinstance(a, (pd.Series, DataArray)) else a b = as_quantity(b) if isinstance(b, (pd.Series, DataArray)) else b assert_series_equal(a, b, **kwargs) elif Quantity is DataArray: # pragma: no cover kwargs.pop('check_dtype', None) assert_xr_allclose(a, b, **kwargs) # check attributes are equal if check_attrs: assert a.attrs == b.attrs
def test_weights_pc_cossim(MockPCA): np.random.seed(0) X = np.random.normal(size=(10000, 2)) Y = X weights = xr.DataArray([ [1, 0], [1. / np.sqrt(2), 1. / np.sqrt(2)], [3 / 5, 4 / 5], ], dims=('mode', 'x_feature')).T results = xr.Dataset( dict(x_weights=weights, y_weights=weights.rename(x_feature='y_feature'))) weights_pc_cossim(None, X, Y, None, None, None, None, results) target_da = xr.DataArray( [[1, 1. / np.sqrt(2), 3. / 5], [0, 1. / np.sqrt(2), 4. / 5]], dims=('x_feature', 'mode')) assert_xr_allclose(results.x_weights_pc_cossim, target_da) assert_xr_allclose(results.y_weights_pc_cossim, target_da.rename(x_feature='y_feature'))
def test_calc_max_n_required(): assert_raises(ValueError, calc_max_n_required) a = xr.DataArray(np.arange(3), dims=('dummy', )) b = xr.DataArray(np.arange(3)[::-1], dims=('dummy', )) mx_n_req = calc_max_n_required(2 * a, 2 * b, a, b) assert_xr_allclose(mx_n_req, xr.DataArray([4, 2, 4], dims=('dummy', )))
def test_analyze_dataset(): def addon_test(estr, X, Y, Xorig, Yorig, x_align_ref, y_align_ref, results, **kwargs): results['addon_var'] = 3. / 8 estr = SVDPLS() X = np.arange(10).reshape(5, 2) Y = X result = gemmr.sample_analysis.analyze_dataset(estr, X, Y, addons=[addon_test]) assert np.isclose(result.between_corrs_sample, 1.) assert np.isclose(result.addon_var, 3. / 8) estr.fit(X, Y) assert np.isclose(estr.assocs_[0], result.between_assocs) assert np.isclose( np.cov(estr.x_scores_[:, 0], estr.y_scores_[:, 0])[0, 1], result.between_covs_sample) tgt_weights = xr.DataArray([[1. / np.sqrt(2)] * 2], dims=('mode', 'x_feature'), coords=dict(x_feature=np.arange(2)), name='x_weights').T tgt_loadings = xr.DataArray(np.ones((1, 2), dtype=float), dims=('mode', 'x_orig_feature'), coords=dict(x_orig_feature=np.arange(2)), name='x_loadings').T assert_xr_allclose(result.x_weights, tgt_weights) assert_xr_allclose(result.x_loadings, tgt_loadings) tgt_weights = tgt_weights.rename('y_weights').rename(x_feature='y_feature') tgt_loadings = tgt_loadings.rename('y_loadings').rename( x_orig_feature='y_orig_feature') assert_xr_allclose(result.y_weights, tgt_weights) assert_xr_allclose(result.y_loadings, tgt_loadings) ### assert np.all(result.x_weights.values > 0) assert np.all(result.y_weights.values > 0) # i.e. if we now use rerun analyze_dataset with ``?_align_ref`` the weights should be negative result = gemmr.sample_analysis.analyze_dataset(estr, X, Y, x_align_ref=-np.eye(2), y_align_ref=-np.eye(2)) ### class MockEstr(): def fit(self, X, Y): raise ValueError() mock_estr = MockEstr() result = gemmr.sample_analysis.analyze_dataset(mock_estr, X, Y, addons=[addon_test]) da_nan = xr.DataArray(np.nan * np.empty((2, 1)), dims=('x_feature', 'mode'), coords=dict(x_feature=np.arange(2))) target_result = xr.Dataset( dict(between_assocs=np.nan, between_covs_sample=np.nan, between_corrs_sample=np.nan, addon_var=3. / 8, x_weights=da_nan, y_weights=da_nan.rename(x_feature='y_feature'), x_loadings=da_nan.rename(x_feature='x_orig_feature'), y_loadings=da_nan.rename(x_feature='y_orig_feature'))) assert_xr_equal(result, target_result)