From d0d0ad3dc8817c6f4d64b02ecb937752ae888a0c Mon Sep 17 00:00:00 2001 From: Lisette Espin Date: Wed, 11 Sep 2024 00:40:45 +0200 Subject: [PATCH] preliminary code for janus --- examples/notebooks/inference.ipynb | 376 +++++++++++++++++- .../algorithms/hypothesis_testing/__init__.py | 3 + netin/algorithms/hypothesis_testing/janus.py | 316 +++++++++++++++ netin/base_class.py | 6 + netin/utils/io.py | 24 ++ setup.py | 1 + 6 files changed, 723 insertions(+), 3 deletions(-) diff --git a/examples/notebooks/inference.ipynb b/examples/notebooks/inference.ipynb index 06f3d5fc..3ff5ce98 100644 --- a/examples/notebooks/inference.ipynb +++ b/examples/notebooks/inference.ipynb @@ -2,14 +2,384 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { - "collapsed": true + "collapsed": true, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:56.022053Z", + "end_time": "2024-09-11T00:32:56.588549Z" + } }, "outputs": [], "source": [ - "" + "from netin.models import PAHModel\n", + "from netin.models import PATCHModel\n", + "from netin.models import CompoundLFM\n", + "from netin.models import BarabasiAlbertModel\n", + "from netin.algorithms.hypothesis_testing import Janus" ] + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "OUTPUT_DIR = 'inference_results'" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:56.591274Z", + "end_time": "2024-09-11T00:32:56.594424Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "N=100\n", + "m=2\n", + "f_m=0.2\n", + "h_m=0.5\n", + "h_M=0.5\n", + "seed=1234\n", + "g_pah = PAHModel(N=N, m=2, f_m=f_m, h_m=h_m, h_M=h_M, seed=seed)\n", + "g_pah = g_pah.simulate()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:56.595637Z", + "end_time": "2024-09-11T00:32:56.635663Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "is_global = False\n", + "k_max = 10\n", + "k_log_scale = False\n", + "verbose = False\n", + "j = Janus(graph=g_pah, is_global=is_global, k_max=k_max, k_log_scale=k_log_scale, verbose=verbose)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:56.634602Z", + "end_time": "2024-09-11T00:32:56.640590Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/espinl/.conda/envs/py39NetIn/lib/python3.9/site-packages/scipy/sparse/_index.py:146: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n", + " self._set_arrayXarray(i, j, x)\n" + ] + } + ], + "source": [ + "h = j.get_uniform_hypothesis()\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:56.710189Z", + "end_time": "2024-09-11T00:32:57.196752Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "h = j.get_self_loop_hypothesis()\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:57.246846Z", + "end_time": "2024-09-11T00:32:57.682834Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [], + "source": [ + "h = j.get_data_hypothesis()\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:57.733243Z", + "end_time": "2024-09-11T00:32:58.168457Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [ + "n_iter = 20\n", + "best_evidence = j.model_fitting(PAHModel, n_iter=n_iter,\n", + " N=N, m=2, f_m=f_m, h_m=h_m, h_M=h_M)\n", + "j.evidences.update(best_evidence)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:58.170845Z", + "end_time": "2024-09-11T00:33:08.065639Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [], + "source": [ + "best_evidence = j.model_fitting(BarabasiAlbertModel, n_iter=n_iter,\n", + " N=N, m=2)\n", + "j.evidences.update(best_evidence)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:08.067869Z", + "end_time": "2024-09-11T00:33:17.708419Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "p_tc = 0.8\n", + "lfm_local = lfm_global = CompoundLFM.UNIFORM\n", + "best_evidence = j.model_fitting(PATCHModel, n_iter=n_iter,\n", + " N=N, m=2, f_m=f_m, h_m=h_m, h_M=h_M, p_tc=p_tc, lfm_local=lfm_local, lfm_global=lfm_global)\n", + "hname = list(best_evidence.keys())[0]\n", + "best_evidence[f'{hname}_{p_tc}'] = best_evidence.pop(hname)\n", + "j.evidences.update(best_evidence)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:17.710303Z", + "end_time": "2024-09-11T00:33:27.639931Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [], + "source": [ + "p_tc = 0.2\n", + "lfm_local = lfm_global = CompoundLFM.UNIFORM\n", + "best_evidence = j.model_fitting(PATCHModel, n_iter=n_iter,\n", + " N=N, m=2, f_m=f_m, h_m=h_m, h_M=h_M, p_tc=p_tc, lfm_local=lfm_local, lfm_global=lfm_global)\n", + "hname = list(best_evidence.keys())[0]\n", + "best_evidence[f'{hname}_{p_tc}'] = best_evidence.pop(hname)\n", + "j.evidences.update(best_evidence)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:27.642084Z", + "end_time": "2024-09-11T00:33:37.679481Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [], + "source": [ + "h = j.get_homophily_hypothesis(h_m=h_m, h_M=h_M)\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:37.730029Z", + "end_time": "2024-09-11T00:33:38.170411Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [], + "source": [ + "h = j.get_homophily_hypothesis(h_m=1.0, h_M=1.0)\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:38.173225Z", + "end_time": "2024-09-11T00:33:38.660963Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [], + "source": [ + "h = j.get_homophily_hypothesis(h_m=0.2, h_M=0.8)\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:38.663469Z", + "end_time": "2024-09-11T00:33:39.149894Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [], + "source": [ + "h = j.get_homophily_hypothesis(h_m=0.2, h_M=0.2)\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:39.154343Z", + "end_time": "2024-09-11T00:33:39.657222Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 16, + "outputs": [], + "source": [ + "h = j.get_homophily_hypothesis(h_m=0.5, h_M=0.5)\n", + "e = j.generate_evidences(h)\n", + "j.add_evidences(h.name, e)\n", + "del(h)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:39.657888Z", + "end_time": "2024-09-11T00:33:40.154087Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "j.plot_evidences(output_dir=OUTPUT_DIR)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:40.155903Z", + "end_time": "2024-09-11T00:33:40.869427Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 18, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "j.plot_evidences(bayes_factors=True, output_dir=OUTPUT_DIR)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:33:40.870634Z", + "end_time": "2024-09-11T00:33:41.230780Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 19, + "outputs": [], + "source": [ + "j.save_evidences(OUTPUT_DIR)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:52.146576Z", + "end_time": "2024-09-11T00:33:41.232914Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 19, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-09-11T00:32:52.146602Z", + "end_time": "2024-09-11T00:33:41.235402Z" + } + } } ], "metadata": { diff --git a/netin/algorithms/hypothesis_testing/__init__.py b/netin/algorithms/hypothesis_testing/__init__.py index e69de29b..ac1cbe52 100644 --- a/netin/algorithms/hypothesis_testing/__init__.py +++ b/netin/algorithms/hypothesis_testing/__init__.py @@ -0,0 +1,3 @@ +from .janus import Janus +from .janus import JanusGraph +from .janus import Hypothesis \ No newline at end of file diff --git a/netin/algorithms/hypothesis_testing/janus.py b/netin/algorithms/hypothesis_testing/janus.py index e69de29b..4dd04749 100644 --- a/netin/algorithms/hypothesis_testing/janus.py +++ b/netin/algorithms/hypothesis_testing/janus.py @@ -0,0 +1,316 @@ +import gc +from collections import defaultdict +from typing import \ + Dict + +import numpy as np +from scipy.sparse import csr_matrix +from scipy.sparse import lil_matrix +from scipy.sparse import triu +from scipy.special import gammaln +from sklearn.preprocessing import normalize + +from ...base_class import BaseClass +from ...graphs.graph import Graph +from ...utils import io + + +class JanusGraph(BaseClass): + + def __init__(self, graph: Graph, **attr): + BaseClass.__init__(self, **attr) + self.graph = graph # netin.Graph + self.adj_matrix: lil_matrix = None + self.adj_matrix_clean: lil_matrix = None + + def init_data(self, is_global: bool = True): + self.adj_matrix = self.graph.get_adjacency_matrix().tolil() * 100 + if is_global: + if self.is_directed(): + # flatten 1 x n^2 + self.adj_matrix_clean = self.adj_matrix.reshape(1, -1) + else: + # just one side (eg. upper diagonal) + self.adj_matrix_clean = triu(self.adj_matrix, k=1) + else: + self.adj_matrix_clean = self.adj_matrix + + + def is_directed(self): + return self.graph.is_directed() + + def number_of_nodes(self): + return self.graph.number_of_nodes() + + def get_node_classes(self): + return self.graph.get_node_classes() + + +class Hypothesis(BaseClass): + + def __init__(self, name: str, belief_matrix: lil_matrix, graph: JanusGraph, is_global: bool, **attr): + BaseClass.__init__(self, **attr) + self.name = name + self.graph = graph + self.is_global = is_global + self.belief_matrix = belief_matrix + self.belief_matrix_normalized: lil_matrix = None + self._init_hypothesis() + + def _init_hypothesis(self): + # set the correct dimensions + if self.is_global: + if self.graph.is_directed(): + # flatten 1 x n^2 + belief_matrix = self.belief_matrix.reshape(1, -1) + else: + # just one side (eg. upper diagonal) + belief_matrix = triu(self.belief_matrix, k=1) + else: + belief_matrix = self.belief_matrix + + # normalize + self.belief_matrix_normalized = normalize(belief_matrix, axis=1, norm='l1', copy=True) + + def elicit_prior(self, k: int) -> lil_matrix: + n = self.graph.number_of_nodes() + kappa = n * (n if self.is_global else 1.0) * k + + if k in [0., 0.1]: + prior = csr_matrix(self.belief_matrix_normalized.shape, dtype=np.float64) + else: + prior = self.belief_matrix_normalized.copy() * kappa + + # rows only 0 --> k + norma = prior.sum(axis=1) + n_zeros, _ = np.where(norma == 0) + prior[n_zeros, :] = k + + return prior + + def compute_evidence(self, prior: lil_matrix, k: int) -> float: + """ + Computes the Categorical Dirichlet evidence + Parameters + ---------- + prior + k + + Returns + ------- + float + Value of the log of the absolute value of gamma + """ + n = self.graph.number_of_nodes() + proto_prior = 1.0 + (k if prior.size == 0 else 0.) + uniform = n * (n if self.is_global else 1.0) * proto_prior + evidence = 0 + evidence += gammaln(prior.sum(axis=1) + uniform).sum() + evidence -= gammaln(self.graph.adj_matrix_clean.sum(axis=1) + prior.sum(axis=1) + uniform).sum() + + self.log('shape graph.data: {} | size: {}'.format(self.graph.adj_matrix_clean.shape, + self.graph.adj_matrix_clean.size)) + self.log('shape prior: {} | size:{}'.format(prior.shape, prior.size)) + + evidence += gammaln((self.graph.adj_matrix_clean + prior).data + proto_prior).sum() + evidence -= gammaln(prior.data + proto_prior).sum() + ( + (self.graph.adj_matrix_clean.size - prior.size) * gammaln(proto_prior)) + ### the uniform is added since it is the starting point for the first value of k + ### the last negative sum includes (graph.size - prior.size) * uniform to include all empty cells + return evidence + + +class Janus(BaseClass): + + def __init__(self, graph: Graph, is_global: bool = True, k_max: int = 10, k_log_scale: bool = True, **attr): + BaseClass.__init__(self, **attr) + self.graph: JanusGraph = JanusGraph(graph, **attr) # graph (from class Graph) + self.graph.init_data(is_global) + self.is_global = is_global # kind of testing: global or local + self.k_max = k_max # maximun value of weighting factor + self.k_log_scale = k_log_scale # whether the weighting factors should be log scale or not + self.weighting_factors: np.ndarray = None + # self.hypotheses: Set[Hypothesis] = set() # Belief matrices + self.evidences: Dict[str, Dict[float, float]] = {} # Evidence values for each hypothesis and weighting factor k + self._init_weighting_factors() + + ### DEFAULT HYPOTHESES + def get_uniform_hypothesis(self) -> Hypothesis: + n = self.graph.number_of_nodes() + h = Hypothesis(name='uniform', belief_matrix=lil_matrix((n, n)), graph=self.graph, is_global=self.is_global) + return h + + def get_self_loop_hypothesis(self) -> Hypothesis: + n = self.graph.number_of_nodes() + diagonal_matrix = lil_matrix((n, n)) + diagonal_matrix.setdiag(1.) + h = Hypothesis(name='self_loop', belief_matrix=diagonal_matrix.tolil(), graph=self.graph, + is_global=self.is_global) + return h + + def get_data_hypothesis(self) -> Hypothesis: + h = Hypothesis(name='data', belief_matrix=self.graph.adj_matrix.tolil(), graph=self.graph, + is_global=self.is_global) + return h + + def get_model_hypothesis(self, model_gen, **args): + g = model_gen(**args) + g.simulate() + h = Hypothesis(name=g.SHORT, + belief_matrix=g.graph.get_adjacency_matrix().tolil(), + graph=self.graph, + is_global=self.is_global) + return h + + def get_homophily_hypothesis(self, h_m: float = 1.0, h_M: float = 1.0): + assert h_m >= 0 and h_m <= 1.0 and h_M >= 0.0 and h_M <= 1.0 + name = f"hm{h_m}_hM{h_M}" + + indices_m = np.where(self.graph.get_node_classes()['minority'].get_values() == 1)[0] + indices_M = np.where(self.graph.get_node_classes()['minority'].get_values() == 0)[0] + + # Size of the matrix + size = max(max(indices_m), max(indices_M)) + 1 + + # Create a lil_matrix of the required size + belief_matrix = lil_matrix((size, size)) + + # Set values for elements in indices_m and indices_M + belief_matrix[np.ix_(indices_m, indices_m)] = h_m + belief_matrix[np.ix_(indices_M, indices_M)] = h_M + + h = Hypothesis(name=name, + belief_matrix=belief_matrix, + graph=self.graph, + is_global=self.is_global) + return h + + def model_fitting(self, model_gen, n_iter=10, **args): + verbose = self.get_verbose() + self.set_verbose(False) + + evidences = {} + for i in range(n_iter): + h = self.get_model_hypothesis(model_gen, **args) + e = self.generate_evidences(h) + evidences[f"{h.name}_{i}"] = e + + # average + sums = defaultdict(int) + counts = defaultdict(int) + + # Iterate over each inner dictionary and sum the values for each key + for inner_dict in evidences.values(): + for key, value in inner_dict.items(): + sums[key] += value + counts[key] += 1 + + # Compute the average for each key + averages = {key: sums[key] / counts[key] for key in sums} + evidences = {model_gen.SHORT: averages} + self.set_verbose(verbose) + return evidences + + ### EVIDENCE + def _init_weighting_factors(self): + ''' + Initializes the weighting factors for the prior elicitation + Parameters + ---------- + k_max + k_log_scale + + Returns + ------- + + ''' + if self.k_log_scale: + self.weighting_factors = np.sort(np.unique(np.append(np.logspace(-1, self.k_max, self.k_max + 2), 1))) + else: + self.weighting_factors = np.arange(0, self.k_max + 1, 1).astype(float) + + def generate_evidences(self, h: Hypothesis): + self.log('===== CALCULATING EVIDENCES =====') + self.log(f'::: Hypothesis: {h.name} :::') + evidences = {} + + for k in self.weighting_factors: + prior = h.elicit_prior(k) + e = h.compute_evidence(prior, k) + evidences[k] = e + self.log(f"h:{h.name:20s}, k={k:10.2f}, e={e:10.2f}") + del (prior) + del (e) + gc.collect() + + return evidences + + def add_evidences(self, name: str, evidences: Dict[float, float]): + self.evidences[name] = evidences + + def save_evidences(self, output_dir: str): + assert output_dir != '' + assert io.validate_dir(output_dir) + fn = io.path_join(output_dir, 'evidences.json') + io.save_dict_to_file(self.evidences, fn) + + def plot_evidences(self, bayes_factors: bool = False, output_dir: str = None, **kwargs): + import matplotlib.pyplot as plt + import operator + + assert (bayes_factors and 'uniform' in self.evidences) or (not bayes_factors) + + fig = plt.figure(figsize=kwargs.get('figsize', (10, 5))) + ax = fig.add_subplot(111) + fig.canvas.draw() + + n = self.graph.number_of_nodes() + for hypothesis_name, evidences_obj in self.evidences.items(): + sorted_evidences_by_k = sorted(evidences_obj.items(), key=operator.itemgetter(0), reverse=False) + + yy = [e[1] - (self.evidences['uniform'][e[0]] if bayes_factors else 0) for e in sorted_evidences_by_k] + xx = [float(e[0]) * (n * (n if self.is_global else 1)) for e in sorted_evidences_by_k] + + if self.k_log_scale: + plot = ax.semilogx + else: + plot = ax.plot + + plot(xx, yy, label=hypothesis_name) # marker, color + + k_rank = max([e[0] for e in sorted_evidences_by_k]) + ax.set_xlabel("concentration parameter $\kappa$") + ax.set_ylabel("log(evidence)" if not bayes_factors else "log(Bayes factor)") + plt.grid(False) + ax.xaxis.grid(True) + + # if self.is_global: + # ax.ticklabel_format(axis='x', style='sci', scilimits=(0, 0)) + + ### Shrink current axis by 20% + box = ax.get_position() + ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) + + handles, labels = ax.get_legend_handles_labels() + tmp = {hypothesis_name: evidence + for hypothesis_name, obj in self.evidences.items() + for k, evidence in obj.items() if k == k_rank} + + t = [(l, h, tmp[l]) for l, h in zip(labels, handles)] + labels, handles, evidences = zip(*sorted(t, key=lambda t: t[2], reverse=True)) + legend = ax.legend(handles, labels, loc='upper center', + bbox_to_anchor=(kwargs.get('bboxx', 1.18), + kwargs.get('bboxy', 1.0)), + fontsize=kwargs.get('fontsize', 13), + ncol=kwargs.get('ncol', 1)) # inside + ax.grid('on') + + if output_dir is not None: + io.validate_dir(output_dir) + plt.savefig(io.path_join(output_dir, f"evidences_{'global' if self.is_global else 'local'}.pdf"), + bbox_extra_artists=(legend,), + bbox_inches='tight', + dpi=kwargs.get('dpi', 1200)) + + plt.show() + plt.close() diff --git a/netin/base_class.py b/netin/base_class.py index 1e9d6536..539e9fe3 100644 --- a/netin/base_class.py +++ b/netin/base_class.py @@ -18,3 +18,9 @@ def get_metadata(self, d_meta_data: Optional[Dict[str, Any]] = None) -> Dict[str def log(self, msg: str): if self._verbose: print(msg) + + def set_verbose(self, verbose:bool): + self._verbose = verbose + + def get_verbose(self) -> bool: + return self._verbose diff --git a/netin/utils/io.py b/netin/utils/io.py index 22904c57..5750dc3c 100644 --- a/netin/utils/io.py +++ b/netin/utils/io.py @@ -1,10 +1,17 @@ +from typing import \ + Dict + import os import glob +import json import pickle import networkx as nx from typing import Union, Tuple +def path_join(*paths): + return os.path.join(*paths) + def read_graph(fn: str) -> Union[nx.Graph, nx.DiGraph]: """ Loads a graph from a file. @@ -26,3 +33,20 @@ def read_graph(fn: str) -> Union[nx.Graph, nx.DiGraph]: return pickle.load(f) else: raise ValueError(f'Unsupported file format: {fn}') + +def save_dict_to_file(dict:Dict, fn): + with open(fn, 'w') as file: + json.dump(dict, file, indent=4) + +def load_dict_from_file(fn): + with open(fn, 'r') as file: + return json.load(file) + +def validate_dir(dir:str) -> bool: + try: + if not os.path.exists(dir): + os.makedirs(dir) + except Exception as ex: + print(ex) + return False + return True \ No newline at end of file diff --git a/setup.py b/setup.py index bc54edaa..c151b58d 100644 --- a/setup.py +++ b/setup.py @@ -63,6 +63,7 @@ "netin.models", "netin.graphs", "netin.algorithms.sampling", + "netin.algorithms.hypothesis_testing", "netin.filters", "netin.link_formation_mechanisms", "netin.utils",