def test_sqrt_transform():
X = data.generate_positive_sparse_matrix()
Y = np.sqrt(X)
matrix.test_all_matrix_types(X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.transform.sqrt)
def test_select_cols_dataframe_index(self):
matrix.test_all_matrix_types(self.X,
scprep.select.select_cols,
idx=pd.DataFrame(np.random.choice(
[True, False], [1, self.X.shape[1]]),
index=[1],
columns=self.X.columns))
def test_subsample_multiple(self):
Y, libsize_sub = scprep.select.subsample(self.X,
self.libsize,
n=20,
seed=42)
def test_fun(X, **kwargs):
libsize = scprep.measure.library_size(X)
return scprep.select.subsample(X, libsize, **kwargs)[0]
matrix.test_all_matrix_types(
self.X,
utils.assert_transform_equals,
Y=Y,
transform=test_fun,
check=utils.assert_all_equal,
n=20,
seed=42,
)
def test_fun(X, **kwargs):
libsize = scprep.measure.library_size(X)
return scprep.select.subsample(X, libsize, **kwargs)[1]
matrix.test_all_matrix_types(
self.X,
utils.assert_transform_equals,
Y=libsize_sub,
transform=test_fun,
check=utils.assert_all_close,
n=20,
seed=42,
)
def test_u_statistic():
X = data.generate_positive_sparse_matrix(shape=(500, 3),
seed=42,
poisson_mean=0.2)
Y = data.generate_positive_sparse_matrix(shape=(500, 3),
seed=42,
poisson_mean=0.3)
u_stat = [
stats.mannwhitneyu(X[:, i], Y[:, i], alternative="two-sided")[0]
for i in range(X.shape[1])
]
def test_fun(X):
return scprep.stats.rank_sum_statistic(
scprep.select.select_rows(X, idx=np.arange(500)),
scprep.select.select_rows(X, idx=np.arange(500, 1000)),
)
matrix.test_all_matrix_types(
np.vstack([X, Y]),
utils.assert_transform_equals,
Y=u_stat,
transform=test_fun,
check=utils.assert_all_close,
)
def test_mean_difference():
X = data.load_10X()
X = scprep.filter.filter_empty_genes(X)
Y = scprep.stats.mean_difference(X.iloc[:20], X.iloc[20:100])
assert np.allclose(np.max(Y), 16.8125)
assert np.allclose(np.min(Y), -0.5625)
def test_fun(X, **kwargs):
return scprep.stats.mean_difference(
scprep.select.select_rows(X, idx=np.arange(20)),
scprep.select.select_rows(X, idx=np.arange(20, 100)),
**kwargs,
)
matrix.test_all_matrix_types(
X,
utils.assert_transform_equals,
Y=Y,
transform=test_fun,
check=utils.assert_all_close,
)
utils.assert_raises_message(
ValueError,
"Expected X and Y to have the same number of columns. "
"Got shapes {}, {}".format(X.shape, X.iloc[:, :10].shape),
scprep.stats.mean_difference,
X,
X.iloc[:, :10],
)
def test_gene_expression_filter_above(self):
genes = np.arange(10)
gene_cols = np.array(self.X_sparse.columns)[genes]
X_filtered = scprep.filter.filter_gene_set_expression(
self.X_sparse,
genes=genes,
percentile=10,
keep_cells="above",
library_size_normalize=False,
)
assert X_filtered.shape[1] == self.X_sparse.shape[1]
assert np.min(np.sum(self.X_sparse[gene_cols], axis=1)) < np.min(
np.sum(X_filtered[gene_cols], axis=1)
)
matrix.test_all_matrix_types(
self.X_sparse,
utils.assert_transform_equals,
Y=X_filtered,
transform=partial(
scprep.filter.filter_gene_set_expression,
genes=genes,
percentile=10,
keep_cells="above",
library_size_normalize=False,
),
)
def test_array_all(self):
matrix.test_all_matrix_types(
self.X_dense,
utils.assert_transform_equals,
Y=self.Y,
transform=scprep.measure.gene_set_expression,
genes=[0])
def test_t_statistic():
X = data.generate_positive_sparse_matrix(shape=(500, 3),
seed=42,
poisson_mean=0.2)
Y = data.generate_positive_sparse_matrix(shape=(500, 3),
seed=42,
poisson_mean=0.3)
u_stat = [
stats.ttest_ind(X[:, i], Y[:, i], equal_var=False)[0]
for i in range(X.shape[1])
]
def test_fun(X):
return scprep.stats.t_statistic(
scprep.select.select_rows(X, idx=np.arange(500)),
scprep.select.select_rows(X, idx=np.arange(500, 1000)),
)
matrix.test_all_matrix_types(
np.vstack([X, Y]),
utils.assert_transform_equals,
Y=u_stat,
transform=test_fun,
check=partial(utils.assert_all_close, rtol=2e-3),
)
def test_knnDREMI():
X = data.generate_positive_sparse_matrix(
shape=(500, 2), seed=42, poisson_mean=5)
Y = scprep.stats.knnDREMI(X[:, 0], X[:, 1])
assert isinstance(Y, float)
np.testing.assert_allclose(Y, 0.16238906)
Y2, drevi = scprep.stats.knnDREMI(X[:, 0], X[:, 1],
plot=True, filename="test.png",
return_drevi=True)
assert Y2 == Y
assert drevi.shape == (20, 20)
matrix.test_all_matrix_types(
X, utils.assert_transform_equals, Y=Y,
transform=partial(_test_fun_2d, fun=scprep.stats.knnDREMI),
check=utils.assert_all_close)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=UserWarning)
assert scprep.stats.knnDREMI(X[:, 0], np.repeat(X[0, 1], X.shape[0]),
return_drevi=True) == (0, None)
assert_raise_message(
ValueError, "Expected k as an integer. Got ",
scprep.stats.knnDREMI, X[:, 0], X[:, 1], k="invalid")
assert_raise_message(
ValueError, "Expected n_bins as an integer. Got ",
scprep.stats.knnDREMI, X[:, 0], X[:, 1], n_bins="invalid")
assert_raise_message(
ValueError, "Expected n_mesh as an integer. Got ",
scprep.stats.knnDREMI, X[:, 0], X[:, 1], n_mesh="invalid")
assert_warns_message(
UserWarning,
"Attempting to calculate kNN-DREMI on a constant array. "
"Returning `0`", scprep.stats.knnDREMI, X[:, 0],
np.zeros_like(X[:, 1]))
def test_subsample(self):
self.X = data.generate_positive_sparse_matrix(shape=(50, 100))
Y = scprep.select.subsample(self.X, n=20, seed=42)
matrix.test_all_matrix_types(
self.X, utils.assert_transform_equals, Y=Y,
transform=scprep.select.subsample,
check=utils.assert_all_equal, n=20, seed=42)
def test_select_rows_sparse_index(self):
matrix.test_all_matrix_types(
self.X, scprep.select.select_rows,
idx=sparse.coo_matrix(np.random.choice([True, False], [1, self.X.shape[0]])))
matrix.test_all_matrix_types(
self.X, scprep.select.select_rows,
idx=sparse.coo_matrix(np.random.choice([True, False], [self.X.shape[0], 1])))
def test_select_cols_integer_list_index(self):
matrix.test_all_matrix_types(
self.X,
scprep.select.select_cols,
idx=np.random.choice(self.X.shape[1],
self.X.shape[1] // 2).tolist(),
)
def test_filter_rare_genes(self):
X_filtered = scprep.filter.filter_rare_genes(self.X_dense)
assert X_filtered.shape[0] == self.X_dense.shape[0]
assert not np.any(X_filtered.sum(0) < 5)
matrix.test_all_matrix_types(self.X_dense,
utils.assert_transform_equals,
Y=X_filtered,
transform=scprep.filter.filter_rare_genes)
def test_check_numeric_copy():
X = data.load_10X()
matrix.test_all_matrix_types(
X,
utils.assert_transform_unchanged,
transform=scprep.sanitize.check_numeric,
copy=True,
)
def test_toarray():
X = data.generate_positive_sparse_matrix(shape=(50, 50))
def test_fun(X):
assert isinstance(scprep.utils.toarray(X), np.ndarray)
matrix.test_all_matrix_types(X, test_fun)
test_fun([X, np.matrix(X)])
def test_libsize_norm_rescale_integer(self):
Y = self.X_norm
matrix.test_all_matrix_types(
self.X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.normalize.library_size_normalize,
check=utils.assert_all_close,
rescale=1)
def test_remove_empty_cells():
X = data.load_10X(sparse=False)
X_filtered = scprep.filter.remove_empty_cells(X)
assert X_filtered.shape[1] == X.shape[1]
assert not np.any(X_filtered.sum(1) == 0)
matrix.test_all_matrix_types(X,
utils.assert_transform_equals,
Y=X_filtered,
transform=scprep.filter.remove_empty_cells)
def test_remove_rare_genes():
X = data.load_10X(sparse=False)
X_filtered = scprep.filter.remove_rare_genes(X)
assert X_filtered.shape[0] == X.shape[0]
assert not np.any(X_filtered.sum(0) < 5)
matrix.test_all_matrix_types(X,
utils.assert_transform_equals,
Y=X_filtered,
transform=scprep.filter.remove_rare_genes)
def test_select_rows_dataframe_index(self):
matrix.test_all_matrix_types(
self.X,
scprep.select.select_rows,
idx=pd.DataFrame(
np.random.choice([True, False], [self.X.shape[0], 1]),
index=self.X.index,
),
)
def test_filter_empty_genes_sparse(self):
X_filtered = scprep.filter.filter_empty_genes(self.X_sparse)
assert X_filtered.shape[0] == self.X_sparse.shape[0]
assert not np.any(X_filtered.sum(0) == 0)
matrix.test_all_matrix_types(
self.X_sparse,
utils.assert_transform_equals,
Y=X_filtered,
transform=scprep.filter.filter_empty_genes)
def test_mutual_information():
X = data.generate_positive_sparse_matrix(
shape=(500, 2), seed=42, poisson_mean=5)
Y = scprep.stats.mutual_information(X[:, 0], X[:, 1], bins=20)
assert isinstance(Y, float)
np.testing.assert_allclose(Y, calc_MI(X[:, 0], X[:, 1], bins=20))
matrix.test_all_matrix_types(
X, utils.assert_transform_equals, Y=Y,
transform=partial(_test_fun_2d, fun=scprep.stats.mutual_information),
check=utils.assert_all_close, bins=20)
def test_libsize_norm_return_libsize_rescale_constant(self):
def test_fun(*args, **kwargs):
return scprep.normalize.library_size_normalize(
*args, return_library_size=True, rescale=1, **kwargs)[1]
matrix.test_all_matrix_types(self.X,
utils.assert_transform_equals,
Y=self.libsize,
transform=test_fun,
check=utils.assert_all_close)
def test_libsize_norm_rescale_mean(self):
Y = self.X_norm * self.mean
utils.assert_all_close(Y.sum(1), np.mean(np.sum(self.X, 1)))
matrix.test_all_matrix_types(
self.X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.normalize.library_size_normalize,
check=utils.assert_all_close,
rescale='mean')
def test_toarray():
X = data.generate_positive_sparse_matrix(shape=(50, 50))
def test_fun(X):
assert isinstance(scprep.utils.toarray(X), np.ndarray)
matrix.test_all_matrix_types(X, test_fun)
test_fun([X, np.matrix(X)])
assert_raise_message(TypeError, "Expected array-like. Got ",
scprep.utils.toarray, "hello")
def test_library_size_filter():
X = data.load_10X(sparse=True)
X_filtered = scprep.filter.filter_library_size(X, 100)
assert X_filtered.shape[1] == X.shape[1]
assert not np.any(X_filtered.sum(1) <= 100)
matrix.test_all_matrix_types(X,
utils.assert_transform_equals,
Y=X_filtered,
transform=partial(
scprep.filter.filter_library_size,
cutoff=100))
def test_toarray():
X = data.generate_positive_sparse_matrix(shape=(50, 50))
def test_fun(X):
assert isinstance(scprep.utils.toarray(X), np.ndarray)
matrix.test_all_matrix_types(X, test_fun)
test_fun(np.matrix(X))
assert_raise_message(
TypeError, "Expected pandas DataFrame, scipy sparse matrix or "
"numpy matrix. Got ", scprep.utils.toarray, "hello")
def test_matrix_elementwise_multiply_guess_col():
X = data.generate_positive_sparse_matrix(shape=(50, 100))
x = X[0] + 1
Y = pd.DataFrame(X).mul(x, axis=1)
matrix.test_all_matrix_types(
X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.utils.matrix_vector_elementwise_multiply,
check=utils.assert_all_close,
axis=None,
multiplier=x)
def test_libsize_norm_rescale_median(self):
Y = self.X_norm * self.median
utils.assert_all_close(Y.sum(1), np.median(np.sum(self.X, 1)))
Y2, libsize2 = scprep.normalize.library_size_normalize(
self.X, return_library_size=True)
np.testing.assert_allclose(Y, Y2)
np.testing.assert_allclose(self.libsize, libsize2)
matrix.test_all_matrix_types(
self.X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.normalize.library_size_normalize,
check=utils.assert_all_close)
def test_arcsinh_transform():
X = data.generate_positive_sparse_matrix()
Y = np.arcsinh(X / 5)
matrix.test_all_matrix_types(X,
utils.assert_transform_equivalent,
Y=Y,
transform=scprep.transform.arcsinh,
check=utils.assert_all_close)
assert_raise_message(ValueError, "Expected cofactor > 0 or None. "
"Got 0",
scprep.transform.arcsinh,
data=X,
cofactor=0)
def test_EMD():
X = data.generate_positive_sparse_matrix(
shape=(500, 2), seed=42, poisson_mean=5)
Y = scprep.stats.EMD(X[:, 0], X[:, 1])
assert isinstance(Y, float)
np.testing.assert_allclose(Y, 0.5537161)
matrix.test_all_matrix_types(
X, utils.assert_transform_equals, Y=Y,
transform=partial(_test_fun_2d, fun=scprep.stats.EMD),
check=utils.assert_all_close)
assert_raise_message(
ValueError, "Expected x and y to be 1D arrays. "
"Got shapes x {}, y {}".format(X.shape, X[:, 1].shape),
scprep.stats.EMD, X, X[:, 1])
