def run_fit(
seed,
n_components_try_range,
n_components_try_rdpg,
n_block_try_range,
directed,
n_init,
embed_kws_try_range,
n_jobs,
):
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
np.random.seed(seed)
param_grid = {
"n_components": n_components_try_range,
"n_blocks": n_block_try_range,
"embed_kws": embed_kws_try_range,
}
out_df = select_dcsbm(
graph,
param_grid,
directed=directed,
degree_directed=False,
n_jobs=n_jobs,
n_init=n_init,
)
print(out_df.head())
save_obj(out_df, file_obs, "grid_search_out")
return 0
def run_fit(seed, param_grid, directed, n_init, n_jobs, co_block):
# run left
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
sbm_left_df = select_sbm(
graph,
param_grid,
directed=directed,
n_jobs=n_jobs,
n_init=n_init,
co_block=co_block,
)
save_obj(sbm_left_df, file_obs, "cosbm_left_df")
# run right
graph = load_drosophila_right()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
sbm_right_df = select_sbm(
graph,
param_grid,
directed=directed,
n_jobs=n_jobs,
n_init=n_init,
co_block=co_block,
)
save_obj(sbm_right_df, file_obs, "cosbm_right_df")
return 0
def load_left():
"""
Load the left connectome. Wraps graspy
"""
graph, labels = load_drosophila_left(return_labels=True)
graph = binarize(graph)
return graph, labels
def run_fit(seed, param_grid, directed, n_init, n_jobs):
# run left
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
ddcsbm_left_df = select_dcsbm(
graph,
param_grid,
directed=directed,
degree_directed=False,
n_jobs=n_jobs,
n_init=n_init,
)
save_obj(ddcsbm_left_df, file_obs, "ddcsbm_left_df")
# run right
graph = load_drosophila_right()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
ddcsbm_right_df = select_dcsbm(
graph,
param_grid,
directed=directed,
degree_directed=False,
n_jobs=n_jobs,
n_init=n_init,
)
save_obj(ddcsbm_right_df, file_obs, "ddcsbm_right_df")
return 0
def run_fit(seed, param_grid, directed, n_init, n_jobs):
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
np.random.seed(seed)
dcsbm_out_df = select_dcsbm(
graph,
param_grid,
directed=directed,
degree_directed=False,
n_jobs=n_jobs,
n_init=n_init,
)
ddcsbm_out_df = select_dcsbm(
graph,
param_grid,
directed=directed,
degree_directed=True,
n_jobs=n_jobs,
n_init=n_init,
)
save_obj(dcsbm_out_df, file_obs, "dcsbm_out_df")
save_obj(ddcsbm_out_df, file_obs, "ddcsbm_out_df")
return 0
def run_fit(
seed,
n_components_try_range,
n_components_try_rdpg,
n_block_try_range,
directed,
n_sims_sbm,
):
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
connected = is_fully_connected(graph)
if not connected:
heatmap(graph)
plt.show()
raise ValueError("input graph not connected")
np.random.seed(seed)
columns = columns = [
"n_params_gmm",
"n_params_sbm",
"rss",
"mse",
"score",
"n_components_try",
"n_block_try",
"sim_ind",
]
sbm_master_df = pd.DataFrame(columns=columns)
for i in range(n_sims_sbm):
sbm_df = select_sbm(graph,
n_components_try_range,
n_block_try_range,
directed=directed)
sbm_df["sim_ind"] = i
sbm_master_df = sbm_master_df.append(sbm_df,
ignore_index=True,
sort=True)
rdpg_df = select_rdpg(graph, n_components_try_rdpg, directed)
def metric(assignments, *args):
return -compute_mse_from_assignments(
assignments, graph, directed=directed)
tsbm_master_df = select_sbm(
graph,
n_components_try_range,
n_block_try_range,
directed=directed,
method="bc-metric",
metric=metric,
)
return (sbm_master_df, rdpg_df, tsbm_master_df)
def run_fit(seed, param_grid, directed, n_jobs):
np.random.seed(seed)
# run left
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
rdpg_left_df = select_rdpg(graph, param_grid, directed=directed, n_jobs=n_jobs)
save_obj(rdpg_left_df, file_obs, "rdpg_left_df")
# run right
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
rdpg_right_df = select_rdpg(graph, param_grid, directed=directed, n_jobs=n_jobs)
save_obj(rdpg_right_df, file_obs, "rdpg_right_df")
return 0
def run_fit(
seed,
n_components_try_range,
n_components_try_rdpg,
n_block_try_range,
directed,
n_sims_sbm,
):
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
connected = is_fully_connected(graph)
if not connected:
heatmap(graph)
plt.show()
raise ValueError("input graph not connected")
np.random.seed(seed)
columns = columns = [
"n_params_gmm",
"n_params_sbm",
"rss",
"mse",
"score",
"n_components_try",
"n_block_try",
"sim_ind",
]
sbm_master_df = pd.DataFrame(columns=columns)
for i in range(n_sims_sbm):
sbm_df = select_sbm(
graph,
n_components_try_range,
n_block_try_range,
directed=directed,
rank="sweep",
)
sbm_df["sim_ind"] = i
sbm_master_df = sbm_master_df.append(sbm_df,
ignore_index=True,
sort=True)
save_obj(sbm_master_df, file_obs, "sbm_master_df")
return 0
def run_fit(seed, n_components_try_range, n_components_try_rdpg,
n_block_try_range, directed):
graph = load_drosophila_left()
if not directed:
graph = symmetrize(graph, method="avg")
graph = binarize(graph)
connected = is_fully_connected(graph)
if not connected:
heatmap(graph)
plt.show()
raise ValueError("input graph not connected")
np.random.seed(seed)
sbm_df = select_sbm(graph,
n_components_try_range,
n_block_try_range,
directed=directed)
rdpg_df = select_rdpg(graph, n_components_try_rdpg, directed)
return (sbm_df, rdpg_df)
import numpy as np
import seaborn as sns
from graspy.datasets import load_drosophila_left
from graspy.embed import AdjacencySpectralEmbed
from graspy.models import EREstimator, RDPGEstimator, SBEstimator
from graspy.plot import heatmap, pairplot
import pandas as pd
#%% Set up some simulations
from graspy.simulations import p_from_latent, sample_edges
from graspy.utils import binarize, symmetrize
## Load data
sns.set_context("talk")
left_adj, cell_labels = load_drosophila_left(return_labels=True)
left_adj_uw = left_adj.copy()
left_adj_uw[left_adj_uw > 0] = 1
left_adj_uw = symmetrize(left_adj_uw, method="avg")
left_adj_uw = binarize(left_adj_uw)
def _check_common_inputs(
figsize=None,
height=None,
title=None,
context=None,
font_scale=None,
legend_name=None,
):
from graspy.datasets import load_drosophila_left, load_drosophila_right
from graspy.inference import LatentDistributionTest
left_graph = load_drosophila_left()
right_graph = load_drosophila_right()
ldt = LatentDistributionTest(n_components=3, n_bootstraps=500)
p_value = ldt.fit(left_graph, right_graph)
print("p-value: " + str(p_value))
