From 13073684296f13d907dcb027b3963f00c5e44f39 Mon Sep 17 00:00:00 2001 From: Libing Bai <51594106+922397935@users.noreply.github.com> Date: Tue, 30 Jun 2026 16:00:15 +0800 Subject: [PATCH 1/3] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=A4=9A=E5=B1=82?= =?UTF-8?q?=E8=B6=85=E5=9B=BE=E7=B1=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- multilayer_hypergraph.py | 221 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 multilayer_hypergraph.py diff --git a/multilayer_hypergraph.py b/multilayer_hypergraph.py new file mode 100644 index 0000000..ba1c850 --- /dev/null +++ b/multilayer_hypergraph.py @@ -0,0 +1,221 @@ +import random +import re +import itertools + +import matplotlib.pyplot as plt +import torch + +from typing import Optional, Union, List +from dhg import Hypergraph +from tqdm import tqdm + + +class MultilayerHypergraph(Hypergraph): + r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. + Args: + ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. + ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. + ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. + ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. + ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. + ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. + ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. + ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. + """ + + def __init__(self, + num_v: int, + num_layers: int, + layers_list: Optional[List[Hypergraph]], + e_list: Optional[Union[List[int], List[List[int]]]] = None, + e_weight: Optional[Union[float, List[float]]] = None, + v_weight: Optional[List[float]] = None, + prob_inner_layer_connect: float = 0, + device: torch.device = torch.device('cpu')) -> None: + + super().__init__(num_v, e_list, e_weight, v_weight, device=device) + + assert num_v > 1, "number of node must be greater than 1" + assert num_layers > 1, "number of layers must be greater than 1" + assert num_layers == len( + layers_list), "number of layers must be equal the length of layers_list" + assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" + + self.num_layers = num_layers + self.layers_list = layers_list + self.prob_inner_layer_connect = prob_inner_layer_connect + self.device = device + self.node_sum_before = [] # 总的节点数必须是列表类型 + self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 + + def construct_multi_layer_hypergraph(self) -> Hypergraph: + r""" + Construct the multilayer hypergraph. + """ + + print("Multilayer hypergraph constructing...") + + prob = self.prob_inner_layer_connect + _node_layer = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + + for i in tqdm(range(self.num_layers)): + _node_layer.append( + MultilayerHypergraph.select_nodes( + range( + self.layers_list[i].num_v), + prob)) + self.node_sum_before.append(sum(layer_num_v[:i])) + self.node_layer.append( + MultilayerHypergraph.add_numbers_list( + _node_layer, self.node_sum_before[i])) + + temp = [ + self.node_layer[i][j] for i in range( + self.num_layers) for j in range( + self.num_layers) if i == j] + between_layer_hyperedges = list(itertools.product(*temp)) + inter_layer_hyperedges_list = self._inter_layer_connect() + between_layer_hyperedges += [ + edge for edges in inter_layer_hyperedges_list for edge in edges] + + print("Multilayer hypergraph constructed") + return MultilayerHypergraph( + self.num_v_multi(), + self.num_layers, + self.layers_list, + e_list=between_layer_hyperedges, + device=self.device) + + def num_v_multi(self) -> int: + r""" + the number of node in multi-hyper-network + """ + layer_num_v = [] + for i in range(self.num_layers): + layer_num_v.append(self.layers_list[i].num_v) + return sum(layer_num_v) + + def _inter_layer_connect(self) -> list: + r"""多层超图排序后的超边列表(无层间超边) + """ + layer_e_list = [layer.e[0] for layer in self.layers_list] + layer_num_v = [layer.num_v for layer in self.layers_list] + _layers_e_list = [] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _layers_e_list.append( + MultilayerHypergraph.add_numbers_list( + layer_e_list[i], self.node_sum_before[i])) + return _layers_e_list + + def load_interlayer_mapping(self, + path: Optional[Union[str, List[str]]], + save: bool = False, + save_path=None): + r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 + :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 + 若无,则用文件路径列表,每个文件对应一层的映射关系 + return: 等待添加的层间超边 + example: + file_path = "../data/integrated/gene_merged_file.txt" + merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) + bio_mhg.add_hyperedges(merge_gene_mapping) + """ + if isinstance(path, str): + gene_encoding = {} + with open(path, 'r') as file: + for line in file: + gene, codes = re.findall( + r'([^\[]+)\s+\[([^\]]+)\]', line)[0] + codes = [int(code) for code in codes.split(',')] + if len(codes) > 1: + gene_encoding[gene] = codes + + hyperedges_list = [] + for key in gene_encoding.keys(): + # 只有一个编码的不用加入 + if len(gene_encoding[key]) == 1: + continue + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + if save: + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + elif isinstance(path, list): + gene_info = {} + gene_encoding = {} + # 遍历文件列表 + for file in path: + with open(file, 'r') as f: + for line in f: + gene, code = line.strip().split('\t') + if gene not in gene_encoding: + gene_info[gene] = int(code) + gene_encoding[gene] = [int(code)] + else: + gene_encoding[gene].append(int(code)) + # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 + hyperedges_list = [] + for key in gene_encoding.keys(): + # 这会过滤掉那些多层超图里只出现过一次的基因 + if len(gene_encoding[key]) == 1: + continue + # 这会不过滤,保留所有基因 + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + # print(hyperedges_list) + if save: + # 将结果存储到新的txt文件 + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + with open(save_path, 'w') as f: + for gene, code in gene_info.items(): + f.write(f"{gene} {code}\n") + return hyperedges_list + + def node_layer_list(self) -> List[List[int]]: + r"""返回多层超图的节点列表(有层次) + """ + _node_layer_list = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + layer_v_list = [layer.v for layer in self.layers_list] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _node_layer_list.append( + [num + self.node_sum_before[i] for num in layer_v_list[i]]) + return _node_layer_list + + @staticmethod + def select_nodes(num_v: int, prob: float) -> list: + r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" + res = [] + for i in range(len(num_v)): + if random.random() < prob: + res.append(num_v[i]) + return res + + @staticmethod + def add_numbers_list(lst: List[List[int]], num: int) -> list: + res = [] + for e in lst: + new = [i + num for i in e] + res.append(tuple(new)) + return res + + def __str__(self): + r"""Print the multilayer_biological_hypernetwork hypergraph information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + + def __repr__(self): + r"""Print the multilayer_biological_hypernetwork hypergrpah information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + \ No newline at end of file From b56aa49abc92155a4f3b0c794c8e8b22478d0b8b Mon Sep 17 00:00:00 2001 From: Libing Bai <51594106+q923397935@users.noreply.github.com> Date: Tue, 30 Jun 2026 16:52:31 +0800 Subject: [PATCH 2/3] Added multilayer hypergraph --- dhg/structure/__init__.py | 3 +- dhg/structure/hypergraphs/__init__.py | 1 + .../hypergraphs/multilayer_hypergraph.py | 440 ++++++++--------- examples/plot_multilayer_hg.ipynb | 453 ++++++++++++++++++ tests/structure/test_multilayer_hypergraph.py | 62 +++ 5 files changed, 738 insertions(+), 221 deletions(-) rename multilayer_hypergraph.py => dhg/structure/hypergraphs/multilayer_hypergraph.py (97%) create mode 100644 examples/plot_multilayer_hg.ipynb create mode 100644 tests/structure/test_multilayer_hypergraph.py diff --git a/dhg/structure/__init__.py b/dhg/structure/__init__.py index 3b32e95..5ca1342 100644 --- a/dhg/structure/__init__.py +++ b/dhg/structure/__init__.py @@ -1,7 +1,7 @@ from .base import load_structure, BaseGraph, BaseHypergraph from .graphs import Graph, DiGraph, BiGraph from .hypergraphs import Hypergraph - +from .hypergraphs import MultilayerHypergraph __all__ = [ "load_structure", @@ -11,4 +11,5 @@ "DiGraph", "BiGraph", "Hypergraph", + "MultilayerHypergraph" ] diff --git a/dhg/structure/hypergraphs/__init__.py b/dhg/structure/hypergraphs/__init__.py index d9ed176..fda3eb2 100644 --- a/dhg/structure/hypergraphs/__init__.py +++ b/dhg/structure/hypergraphs/__init__.py @@ -1 +1,2 @@ from .hypergraph import Hypergraph +from .multilayer_hypergraph import MultilayerHypergraph diff --git a/multilayer_hypergraph.py b/dhg/structure/hypergraphs/multilayer_hypergraph.py similarity index 97% rename from multilayer_hypergraph.py rename to dhg/structure/hypergraphs/multilayer_hypergraph.py index ba1c850..a49128e 100644 --- a/multilayer_hypergraph.py +++ b/dhg/structure/hypergraphs/multilayer_hypergraph.py @@ -1,221 +1,221 @@ -import random -import re -import itertools - -import matplotlib.pyplot as plt -import torch - -from typing import Optional, Union, List -from dhg import Hypergraph -from tqdm import tqdm - - -class MultilayerHypergraph(Hypergraph): - r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. - Args: - ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. - ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. - ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. - ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. - ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. - ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. - ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. - ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. - """ - - def __init__(self, - num_v: int, - num_layers: int, - layers_list: Optional[List[Hypergraph]], - e_list: Optional[Union[List[int], List[List[int]]]] = None, - e_weight: Optional[Union[float, List[float]]] = None, - v_weight: Optional[List[float]] = None, - prob_inner_layer_connect: float = 0, - device: torch.device = torch.device('cpu')) -> None: - - super().__init__(num_v, e_list, e_weight, v_weight, device=device) - - assert num_v > 1, "number of node must be greater than 1" - assert num_layers > 1, "number of layers must be greater than 1" - assert num_layers == len( - layers_list), "number of layers must be equal the length of layers_list" - assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" - - self.num_layers = num_layers - self.layers_list = layers_list - self.prob_inner_layer_connect = prob_inner_layer_connect - self.device = device - self.node_sum_before = [] # 总的节点数必须是列表类型 - self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 - - def construct_multi_layer_hypergraph(self) -> Hypergraph: - r""" - Construct the multilayer hypergraph. - """ - - print("Multilayer hypergraph constructing...") - - prob = self.prob_inner_layer_connect - _node_layer = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - - for i in tqdm(range(self.num_layers)): - _node_layer.append( - MultilayerHypergraph.select_nodes( - range( - self.layers_list[i].num_v), - prob)) - self.node_sum_before.append(sum(layer_num_v[:i])) - self.node_layer.append( - MultilayerHypergraph.add_numbers_list( - _node_layer, self.node_sum_before[i])) - - temp = [ - self.node_layer[i][j] for i in range( - self.num_layers) for j in range( - self.num_layers) if i == j] - between_layer_hyperedges = list(itertools.product(*temp)) - inter_layer_hyperedges_list = self._inter_layer_connect() - between_layer_hyperedges += [ - edge for edges in inter_layer_hyperedges_list for edge in edges] - - print("Multilayer hypergraph constructed") - return MultilayerHypergraph( - self.num_v_multi(), - self.num_layers, - self.layers_list, - e_list=between_layer_hyperedges, - device=self.device) - - def num_v_multi(self) -> int: - r""" - the number of node in multi-hyper-network - """ - layer_num_v = [] - for i in range(self.num_layers): - layer_num_v.append(self.layers_list[i].num_v) - return sum(layer_num_v) - - def _inter_layer_connect(self) -> list: - r"""多层超图排序后的超边列表(无层间超边) - """ - layer_e_list = [layer.e[0] for layer in self.layers_list] - layer_num_v = [layer.num_v for layer in self.layers_list] - _layers_e_list = [] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _layers_e_list.append( - MultilayerHypergraph.add_numbers_list( - layer_e_list[i], self.node_sum_before[i])) - return _layers_e_list - - def load_interlayer_mapping(self, - path: Optional[Union[str, List[str]]], - save: bool = False, - save_path=None): - r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 - :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 - 若无,则用文件路径列表,每个文件对应一层的映射关系 - return: 等待添加的层间超边 - example: - file_path = "../data/integrated/gene_merged_file.txt" - merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) - bio_mhg.add_hyperedges(merge_gene_mapping) - """ - if isinstance(path, str): - gene_encoding = {} - with open(path, 'r') as file: - for line in file: - gene, codes = re.findall( - r'([^\[]+)\s+\[([^\]]+)\]', line)[0] - codes = [int(code) for code in codes.split(',')] - if len(codes) > 1: - gene_encoding[gene] = codes - - hyperedges_list = [] - for key in gene_encoding.keys(): - # 只有一个编码的不用加入 - if len(gene_encoding[key]) == 1: - continue - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - if save: - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") - elif isinstance(path, list): - gene_info = {} - gene_encoding = {} - # 遍历文件列表 - for file in path: - with open(file, 'r') as f: - for line in f: - gene, code = line.strip().split('\t') - if gene not in gene_encoding: - gene_info[gene] = int(code) - gene_encoding[gene] = [int(code)] - else: - gene_encoding[gene].append(int(code)) - # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 - hyperedges_list = [] - for key in gene_encoding.keys(): - # 这会过滤掉那些多层超图里只出现过一次的基因 - if len(gene_encoding[key]) == 1: - continue - # 这会不过滤,保留所有基因 - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - # print(hyperedges_list) - if save: - # 将结果存储到新的txt文件 - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") - with open(save_path, 'w') as f: - for gene, code in gene_info.items(): - f.write(f"{gene} {code}\n") - return hyperedges_list - - def node_layer_list(self) -> List[List[int]]: - r"""返回多层超图的节点列表(有层次) - """ - _node_layer_list = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - layer_v_list = [layer.v for layer in self.layers_list] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _node_layer_list.append( - [num + self.node_sum_before[i] for num in layer_v_list[i]]) - return _node_layer_list - - @staticmethod - def select_nodes(num_v: int, prob: float) -> list: - r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" - res = [] - for i in range(len(num_v)): - if random.random() < prob: - res.append(num_v[i]) - return res - - @staticmethod - def add_numbers_list(lst: List[List[int]], num: int) -> list: - res = [] - for e in lst: - new = [i + num for i in e] - res.append(tuple(new)) - return res - - def __str__(self): - r"""Print the multilayer_biological_hypernetwork hypergraph information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) - - def __repr__(self): - r"""Print the multilayer_biological_hypernetwork hypergrpah information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) +import random +import re +import itertools + +import matplotlib.pyplot as plt +import torch + +from typing import Optional, Union, List +from dhg import Hypergraph +from tqdm import tqdm + + +class MultilayerHypergraph(Hypergraph): + r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. + Args: + ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. + ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. + ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. + ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. + ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. + ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. + ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. + ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. + """ + + def __init__(self, + num_v: int, + num_layers: int, + layers_list: Optional[List[Hypergraph]], + e_list: Optional[Union[List[int], List[List[int]]]] = None, + e_weight: Optional[Union[float, List[float]]] = None, + v_weight: Optional[List[float]] = None, + prob_inner_layer_connect: float = 0, + device: torch.device = torch.device('cpu')) -> None: + + super().__init__(num_v, e_list, e_weight, v_weight, device=device) + + assert num_v > 1, "number of node must be greater than 1" + assert num_layers > 1, "number of layers must be greater than 1" + assert num_layers == len( + layers_list), "number of layers must be equal the length of layers_list" + assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" + + self.num_layers = num_layers + self.layers_list = layers_list + self.prob_inner_layer_connect = prob_inner_layer_connect + self.device = device + self.node_sum_before = [] # 总的节点数必须是列表类型 + self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 + + def construct_multi_layer_hypergraph(self) -> Hypergraph: + r""" + Construct the multilayer hypergraph. + """ + + print("Multilayer hypergraph constructing...") + + prob = self.prob_inner_layer_connect + _node_layer = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + + for i in tqdm(range(self.num_layers)): + _node_layer.append( + MultilayerHypergraph.select_nodes( + range( + self.layers_list[i].num_v), + prob)) + self.node_sum_before.append(sum(layer_num_v[:i])) + self.node_layer.append( + MultilayerHypergraph.add_numbers_list( + _node_layer, self.node_sum_before[i])) + + temp = [ + self.node_layer[i][j] for i in range( + self.num_layers) for j in range( + self.num_layers) if i == j] + between_layer_hyperedges = list(itertools.product(*temp)) + inter_layer_hyperedges_list = self._inter_layer_connect() + between_layer_hyperedges += [ + edge for edges in inter_layer_hyperedges_list for edge in edges] + + print("Multilayer hypergraph constructed") + return MultilayerHypergraph( + self.num_v_multi(), + self.num_layers, + self.layers_list, + e_list=between_layer_hyperedges, + device=self.device) + + def num_v_multi(self) -> int: + r""" + the number of node in multi-hyper-network + """ + layer_num_v = [] + for i in range(self.num_layers): + layer_num_v.append(self.layers_list[i].num_v) + return sum(layer_num_v) + + def _inter_layer_connect(self) -> list: + r"""多层超图排序后的超边列表(无层间超边) + """ + layer_e_list = [layer.e[0] for layer in self.layers_list] + layer_num_v = [layer.num_v for layer in self.layers_list] + _layers_e_list = [] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _layers_e_list.append( + MultilayerHypergraph.add_numbers_list( + layer_e_list[i], self.node_sum_before[i])) + return _layers_e_list + + def load_interlayer_mapping(self, + path: Optional[Union[str, List[str]]], + save: bool = False, + save_path=None): + r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 + :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 + 若无,则用文件路径列表,每个文件对应一层的映射关系 + return: 等待添加的层间超边 + example: + file_path = "../data/integrated/gene_merged_file.txt" + merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) + bio_mhg.add_hyperedges(merge_gene_mapping) + """ + if isinstance(path, str): + gene_encoding = {} + with open(path, 'r') as file: + for line in file: + gene, codes = re.findall( + r'([^\[]+)\s+\[([^\]]+)\]', line)[0] + codes = [int(code) for code in codes.split(',')] + if len(codes) > 1: + gene_encoding[gene] = codes + + hyperedges_list = [] + for key in gene_encoding.keys(): + # 只有一个编码的不用加入 + if len(gene_encoding[key]) == 1: + continue + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + if save: + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + elif isinstance(path, list): + gene_info = {} + gene_encoding = {} + # 遍历文件列表 + for file in path: + with open(file, 'r') as f: + for line in f: + gene, code = line.strip().split('\t') + if gene not in gene_encoding: + gene_info[gene] = int(code) + gene_encoding[gene] = [int(code)] + else: + gene_encoding[gene].append(int(code)) + # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 + hyperedges_list = [] + for key in gene_encoding.keys(): + # 这会过滤掉那些多层超图里只出现过一次的基因 + if len(gene_encoding[key]) == 1: + continue + # 这会不过滤,保留所有基因 + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + # print(hyperedges_list) + if save: + # 将结果存储到新的txt文件 + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + with open(save_path, 'w') as f: + for gene, code in gene_info.items(): + f.write(f"{gene} {code}\n") + return hyperedges_list + + def node_layer_list(self) -> List[List[int]]: + r"""返回多层超图的节点列表(有层次) + """ + _node_layer_list = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + layer_v_list = [layer.v for layer in self.layers_list] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _node_layer_list.append( + [num + self.node_sum_before[i] for num in layer_v_list[i]]) + return _node_layer_list + + @staticmethod + def select_nodes(num_v: int, prob: float) -> list: + r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" + res = [] + for i in range(len(num_v)): + if random.random() < prob: + res.append(num_v[i]) + return res + + @staticmethod + def add_numbers_list(lst: List[List[int]], num: int) -> list: + res = [] + for e in lst: + new = [i + num for i in e] + res.append(tuple(new)) + return res + + def __str__(self): + r"""Print the multilayer_biological_hypernetwork hypergraph information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + + def __repr__(self): + r"""Print the multilayer_biological_hypernetwork hypergrpah information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) \ No newline at end of file diff --git a/examples/plot_multilayer_hg.ipynb b/examples/plot_multilayer_hg.ipynb new file mode 100644 index 0000000..a71d97c --- /dev/null +++ b/examples/plot_multilayer_hg.ipynb @@ -0,0 +1,453 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import sys, os\n", + "sys.path.append('..')\n", + "\n", + "from data import MultilayerHypergraph\n", + "from dhg.random import hypergraph_Gnm\n", + "import matplotlib.pyplot as plt\n", + "import dhg" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### 先画一个大型图" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "big_hg1 = hypergraph_Gnm(30, 30)\n", + "big_hg2 = hypergraph_Gnm(30, 30)\n", + "big_hg3 = hypergraph_Gnm(30, 30)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_1 = [str(i) for i in range(big_hg1.num_v)]\n", + "e_color_1 = ['r'] * 30 \n", + "v_color_1 = ['r'] * 30 # 节点和边的颜色数平分\n", + "big_hg1.draw(v_label=big_v_label_1, v_color=v_color_1, e_color=e_color_1)\n", + "plt.savefig('figs/big_hg_1.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_1.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_1.pdf', dpi=600)\n", + "plt.savefig('figs/big_hg_1.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_2 = [str(i) for i in range(big_hg2.num_v)]\n", + "e_color_2 = ['b'] * 30 \n", + "v_color_2 = ['b'] * 30 # 节点和边的颜色数平分\n", + "big_hg2.draw(v_label=big_v_label_2, v_color=v_color_2, e_color=e_color_2)\n", + "plt.savefig('figs/big_hg_2.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_2.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_2.pdf', dpi=600)\n", + "plt.savefig('figs/big_hg_2.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_3 = [str(i) for i in range(big_hg3.num_v)]\n", + "e_color_3 = ['g'] * 30 \n", + "v_color_3 = ['g'] * 30 # 节点和边的颜色数平分\n", + "big_hg3.draw(v_label=big_v_label_3, v_color=v_color_3, e_color=e_color_3)\n", + "plt.savefig('figs/big_hg_3.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_3.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_3.png', dpi=600)\n", + "plt.savefig('figs/big_hg_3.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 3/3 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label = [str(i) for i in range(big_mhg.num_v)]\n", + "e_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30\n", + "v_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30 # 节点和边的颜色数平分\n", + "big_mhg.draw(v_label=big_v_label, v_color=v_color, e_color=e_color)\n", + "plt.savefig('figs/large_hg.svg', dpi=600)\n", + "plt.savefig('figs/large_hg.eps', dpi=600)\n", + "plt.savefig('figs/large_hg.pdf', dpi=600)\n", + "plt.savefig('figs/large_hg.png', dpi=600)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### 可自定义层内连接及控制连边概率" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label = [str(i) for i in range(small_mhg.num_v)]\n", + "e_color = ['r'] * 3 + ['b'] * 3\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)\n", + "plt.savefig('figs/small_hg.svg', dpi=600)\n", + "plt.savefig('figs/small_hg.eps', dpi=600)\n", + "plt.savefig('figs/small_hg.pdf', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultilayerHypergraph(num_v=10, num_e=8, num_layers=2, layers_list=[Hypergraph(num_v=5, num_e=3), Hypergraph(num_v=5, num_e=3)], prob_inner_layer_connect=0)\n" + ] + } + ], + "source": [ + "small_mhg.add_hyperedges([[4, 7], [2, 5]])\n", + "print(small_mhg)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label = [str(i) for i in range(small_mhg.num_v)]\n", + "e_color = ['r'] * 4 + ['b'] * 4\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label_temp = [str(i) for i in range(small_mhg_temp.num_v)]\n", + "e_color = ['r'] * 7 + ['b'] * 8\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label_temp, v_color=v_color, e_color=e_color)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dhg_cuda117", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/structure/test_multilayer_hypergraph.py b/tests/structure/test_multilayer_hypergraph.py new file mode 100644 index 0000000..24bd98f --- /dev/null +++ b/tests/structure/test_multilayer_hypergraph.py @@ -0,0 +1,62 @@ +import torch +import pytest +import numpy as np +from dhg import Hypergraph, MultilayerHypergraph +import matplotlib.pyplot as plt + +# from dhg.random.hypergraph import hypergraph_Gnm + + +@pytest.fixture() +def g1(): + e_list = [(0, 1, 2, 5), (0, 1), (2, 3, 4), (3, 2, 4)] + g = Hypergraph(6, e_list) + return g + + +@pytest.fixture() +def g2(): + e_list = [(1, 2, 3), (0, 1, 3), (0, 1), (2, 4, 3), (2, 3)] + e_weight = [0.5, 1, 0.5, 1, 0.5] + g = Hypergraph(5, e_list, e_weight) + return g + + +def test_save(g1, tmp_path): + from dhg import load_structure + + g1.save(tmp_path / "g1") + g2 = load_structure(tmp_path / "g1") + + for e1, e2 in zip(g1.e[0], g2.e[0]): + assert e1 == e2 + for w1, w2 in zip(g1.e[1], g2.e[1]): + assert w1 == w2 + + +# test adjacency matrix +def test_adjacency_matrix(g1): + adj = g1.A + assert adj.shape == (6, 6) + assert np.allclose(adj[0, 1], 1) + assert np.allclose(adj[0, 2], 1) + assert np.allclose(adj[0, 3], 0) + assert np.allclose(adj[0, 4], 0) + assert np.allclose(adj[0, 5], 1) +# test construction +def test_construct_multilayer_hypergraph(): + g1 = g1() + g2 = g2() + + mhg = MultilayerHypergraph(11, 2, [g1, g2]) + assert mhg.num_layers == 2 + assert mhg.layers_list[0] == g1 + assert mhg.layers_list[1] == g2 + assert mhg.num_v == 11 + assert mhg.prob_inner_layer_connect == 0 + assert mhg.device == torch.device('cpu') + +def test_draw(mhg): + mhg.draw() + plt.show() + From c518315fba617d46d8837937a4fae8351449f376 Mon Sep 17 00:00:00 2001 From: Libing Bai <51594106+q923397935@users.noreply.github.com> Date: Mon, 26 Oct 2026 22:05:30 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E4=B8=B0=E5=93=A5?= =?UTF-8?q?=E7=9A=84=E5=BB=BA=E8=AE=AE=E5=81=9A=E4=BA=86=E6=96=B0=E7=9A=84?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 主要在struct和test里 --- dhg/__init__.py | 5 +- .../hypergraphs/multilayer_hypergraph.py | 312 +++++++----------- examples/plot_multilayer_hg.ipynb | 151 ++------- tests/structure/test_multilayer_hypergraph.py | 96 +++--- 4 files changed, 206 insertions(+), 358 deletions(-) diff --git a/dhg/__init__.py b/dhg/__init__.py index ab2742f..238351d 100644 --- a/dhg/__init__.py +++ b/dhg/__init__.py @@ -10,7 +10,7 @@ from .structure import load_structure from .structure import BaseGraph, Graph, DiGraph, BiGraph -from .structure import BaseHypergraph, Hypergraph +from .structure import BaseHypergraph, Hypergraph, MultilayerHypergraph from ._global import AUTHOR_EMAIL, CACHE_ROOT, DATASETS_ROOT, REMOTE_DATASETS_ROOT @@ -37,4 +37,5 @@ "BiGraph", "BaseHypergraph", "Hypergraph", -} + "MultilayerHypergraph", +} \ No newline at end of file diff --git a/dhg/structure/hypergraphs/multilayer_hypergraph.py b/dhg/structure/hypergraphs/multilayer_hypergraph.py index a49128e..62d3ced 100644 --- a/dhg/structure/hypergraphs/multilayer_hypergraph.py +++ b/dhg/structure/hypergraphs/multilayer_hypergraph.py @@ -1,221 +1,153 @@ +import itertools import random import re -import itertools +from typing import Iterable, List, Optional, Union -import matplotlib.pyplot as plt import torch -from typing import Optional, Union, List -from dhg import Hypergraph -from tqdm import tqdm +from .hypergraph import Hypergraph class MultilayerHypergraph(Hypergraph): - r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. - Args: - ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. - ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. - ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. - ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. - ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. - ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. - ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. - ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. - """ - - def __init__(self, - num_v: int, - num_layers: int, - layers_list: Optional[List[Hypergraph]], - e_list: Optional[Union[List[int], List[List[int]]]] = None, - e_weight: Optional[Union[float, List[float]]] = None, - v_weight: Optional[List[float]] = None, - prob_inner_layer_connect: float = 0, - device: torch.device = torch.device('cpu')) -> None: - + """A hypergraph composed of multiple hypergraph layers.""" + + def __init__( + self, + num_v: int, + num_layers: int, + layers_list: List[Hypergraph], + e_list=None, + e_weight=None, + v_weight=None, + prob_inner_layer_connect: float = 0, + device: torch.device = torch.device("cpu"), + ) -> None: super().__init__(num_v, e_list, e_weight, v_weight, device=device) - - assert num_v > 1, "number of node must be greater than 1" - assert num_layers > 1, "number of layers must be greater than 1" - assert num_layers == len( - layers_list), "number of layers must be equal the length of layers_list" - assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" + if num_v <= 1: + raise ValueError("num_v must be greater than 1") + if num_layers <= 1: + raise ValueError("num_layers must be greater than 1") + if layers_list is None or num_layers != len(layers_list): + raise ValueError("num_layers must equal the length of layers_list") + if not 0 <= prob_inner_layer_connect <= 1: + raise ValueError("prob_inner_layer_connect must be between 0 and 1") self.num_layers = num_layers - self.layers_list = layers_list + self.layers_list = list(layers_list) self.prob_inner_layer_connect = prob_inner_layer_connect - self.device = device - self.node_sum_before = [] # 总的节点数必须是列表类型 - self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 + self.node_layer: List[List[int]] = [] - def construct_multi_layer_hypergraph(self) -> Hypergraph: - r""" - Construct the multilayer hypergraph. - """ + def _compute_offsets(self) -> List[int]: + """Return each layer's starting vertex index in the combined structure.""" + offsets = [] + total = 0 + for layer in self.layers_list: + offsets.append(total) + total += layer.num_v + return offsets - print("Multilayer hypergraph constructing...") - - prob = self.prob_inner_layer_connect - _node_layer = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - - for i in tqdm(range(self.num_layers)): - _node_layer.append( - MultilayerHypergraph.select_nodes( - range( - self.layers_list[i].num_v), - prob)) - self.node_sum_before.append(sum(layer_num_v[:i])) - self.node_layer.append( - MultilayerHypergraph.add_numbers_list( - _node_layer, self.node_sum_before[i])) - - temp = [ - self.node_layer[i][j] for i in range( - self.num_layers) for j in range( - self.num_layers) if i == j] - between_layer_hyperedges = list(itertools.product(*temp)) - inter_layer_hyperedges_list = self._inter_layer_connect() - between_layer_hyperedges += [ - edge for edges in inter_layer_hyperedges_list for edge in edges] - - print("Multilayer hypergraph constructed") - return MultilayerHypergraph( - self.num_v_multi(), - self.num_layers, - self.layers_list, - e_list=between_layer_hyperedges, - device=self.device) + def construct_multi_layer_hypergraph(self) -> Hypergraph: + """Build and return the flattened hypergraph for all layers.""" + offsets = self._compute_offsets() + layer_nodes = [ + self.select_nodes(range(layer.num_v), self.prob_inner_layer_connect) + for layer in self.layers_list + ] + self.node_layer = [ + [node + offset for node in nodes] + for nodes, offset in zip(layer_nodes, offsets) + ] + + inter_layer_hyperedges = list(itertools.product(*self.node_layer)) + layer_hyperedges = self._inter_layer_connect() + all_hyperedges = inter_layer_hyperedges + [ + edge for edges in layer_hyperedges for edge in edges + ] + return Hypergraph( + self.num_v_multi(), all_hyperedges, device=self.device + ) def num_v_multi(self) -> int: - r""" - the number of node in multi-hyper-network - """ - layer_num_v = [] - for i in range(self.num_layers): - layer_num_v.append(self.layers_list[i].num_v) - return sum(layer_num_v) - - def _inter_layer_connect(self) -> list: - r"""多层超图排序后的超边列表(无层间超边) - """ - layer_e_list = [layer.e[0] for layer in self.layers_list] - layer_num_v = [layer.num_v for layer in self.layers_list] - _layers_e_list = [] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _layers_e_list.append( - MultilayerHypergraph.add_numbers_list( - layer_e_list[i], self.node_sum_before[i])) - return _layers_e_list - - def load_interlayer_mapping(self, - path: Optional[Union[str, List[str]]], - save: bool = False, - save_path=None): - r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 - :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 - 若无,则用文件路径列表,每个文件对应一层的映射关系 - return: 等待添加的层间超边 - example: - file_path = "../data/integrated/gene_merged_file.txt" - merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) - bio_mhg.add_hyperedges(merge_gene_mapping) + """Return the total number of vertices across all layers.""" + return sum(layer.num_v for layer in self.layers_list) + + def _inter_layer_connect(self) -> List[list]: + """Return each layer's hyperedges with its global vertex offset applied.""" + offsets = self._compute_offsets() + return [ + self.add_numbers_list(layer.e[0], offset) + for layer, offset in zip(self.layers_list, offsets) + ] + + def load_interlayer_mapping( + self, + path: Optional[Union[str, List[str]]], + save: bool = False, + save_path=None, + ) -> List[tuple]: + """Load gene mappings and return hyperedges for genes shared across layers. + + ``path`` may be one file containing ``gene [codes]`` records, or a list + of tab-separated ``genecode`` files, one per layer. """ if isinstance(path, str): gene_encoding = {} - with open(path, 'r') as file: + with open(path, "r", encoding="utf-8") as file: for line in file: - gene, codes = re.findall( - r'([^\[]+)\s+\[([^\]]+)\]', line)[0] - codes = [int(code) for code in codes.split(',')] - if len(codes) > 1: - gene_encoding[gene] = codes - - hyperedges_list = [] - for key in gene_encoding.keys(): - # 只有一个编码的不用加入 - if len(gene_encoding[key]) == 1: - continue - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - if save: - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") + match = re.findall(r"([^\[]+)\s+\[([^\]]+)\]", line) + if not match: + continue + gene, codes = match[0] + gene_encoding[gene.strip()] = [ + int(code.strip()) for code in codes.split(",") + ] elif isinstance(path, list): - gene_info = {} gene_encoding = {} - # 遍历文件列表 - for file in path: - with open(file, 'r') as f: - for line in f: - gene, code = line.strip().split('\t') - if gene not in gene_encoding: - gene_info[gene] = int(code) - gene_encoding[gene] = [int(code)] - else: - gene_encoding[gene].append(int(code)) - # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 - hyperedges_list = [] - for key in gene_encoding.keys(): - # 这会过滤掉那些多层超图里只出现过一次的基因 - if len(gene_encoding[key]) == 1: - continue - # 这会不过滤,保留所有基因 - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - # print(hyperedges_list) - if save: - # 将结果存储到新的txt文件 - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") - with open(save_path, 'w') as f: - for gene, code in gene_info.items(): - f.write(f"{gene} {code}\n") - return hyperedges_list + for file_path in path: + with open(file_path, "r", encoding="utf-8") as file: + for line in file: + gene, code = line.rstrip("\n").split("\t", 1) + gene_encoding.setdefault(gene, []).append(int(code)) + else: + raise TypeError("path must be a file path or a list of file paths") + + if save: + if save_path is None: + raise ValueError("save_path is required when save=True") + with open(save_path, "w", encoding="utf-8") as file: + for gene, codes in gene_encoding.items(): + file.write(f"{gene} {codes}\n") + + return [tuple(codes) for codes in gene_encoding.values() if len(codes) > 1] def node_layer_list(self) -> List[List[int]]: - r"""返回多层超图的节点列表(有层次) - """ - _node_layer_list = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - layer_v_list = [layer.v for layer in self.layers_list] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _node_layer_list.append( - [num + self.node_sum_before[i] for num in layer_v_list[i]]) - return _node_layer_list + """Return the vertices in each layer using flattened global indices.""" + offsets = self._compute_offsets() + return [ + [node + offset for node in layer.v] + for layer, offset in zip(self.layers_list, offsets) + ] @staticmethod - def select_nodes(num_v: int, prob: float) -> list: - r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" - res = [] - for i in range(len(num_v)): - if random.random() < prob: - res.append(num_v[i]) - return res + def select_nodes(num_v: Iterable[int], prob: float) -> list: + """Select each vertex independently with probability ``prob``.""" + return [node for node in num_v if random.random() < prob] @staticmethod - def add_numbers_list(lst: List[List[int]], num: int) -> list: - res = [] - for e in lst: - new = [i + num for i in e] - res.append(tuple(new)) - return res + def add_numbers_list(lst: Iterable[Iterable[int]], num: int) -> list: + """Add ``num`` to every vertex in each hyperedge.""" + return [tuple(vertex + num for vertex in edge) for edge in lst] def __str__(self): - r"""Print the multilayer_biological_hypernetwork hypergraph information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + return ( + "MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, " + "layers_list={}, prob_inner_layer_connect={})" + ).format( + self.num_v, + self.num_e, + self.num_layers, + self.layers_list, + self.prob_inner_layer_connect, + ) - def __repr__(self): - r"""Print the multilayer_biological_hypernetwork hypergrpah information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) - \ No newline at end of file + __repr__ = __str__ \ No newline at end of file diff --git a/examples/plot_multilayer_hg.ipynb b/examples/plot_multilayer_hg.ipynb index a71d97c..8ee3e7d 100644 --- a/examples/plot_multilayer_hg.ipynb +++ b/examples/plot_multilayer_hg.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": { "pycharm": { "name": "#%%\n" @@ -10,10 +10,8 @@ }, "outputs": [], "source": [ - "import sys, os\n", - "sys.path.append('..')\n", - "\n", - "from data import MultilayerHypergraph\n", + "import sys\n", + "from dhg import MultilayerHypergraph\n", "from dhg.random import hypergraph_Gnm\n", "import matplotlib.pyplot as plt\n", "import dhg" @@ -32,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" @@ -47,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": { "collapsed": false, "pycharm": { @@ -57,7 +55,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -70,16 +68,12 @@ "big_v_label_1 = [str(i) for i in range(big_hg1.num_v)]\n", "e_color_1 = ['r'] * 30 \n", "v_color_1 = ['r'] * 30 # 节点和边的颜色数平分\n", - "big_hg1.draw(v_label=big_v_label_1, v_color=v_color_1, e_color=e_color_1)\n", - "plt.savefig('figs/big_hg_1.svg', dpi=600)\n", - "plt.savefig('figs/big_hg_1.eps', dpi=600)\n", - "plt.savefig('figs/big_hg_1.pdf', dpi=600)\n", - "plt.savefig('figs/big_hg_1.png', dpi=600)" + "big_hg1.draw(v_label=big_v_label_1, v_color=v_color_1, e_color=e_color_1)\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": { "collapsed": false, "pycharm": { @@ -89,7 +83,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -102,16 +96,12 @@ "big_v_label_2 = [str(i) for i in range(big_hg2.num_v)]\n", "e_color_2 = ['b'] * 30 \n", "v_color_2 = ['b'] * 30 # 节点和边的颜色数平分\n", - "big_hg2.draw(v_label=big_v_label_2, v_color=v_color_2, e_color=e_color_2)\n", - "plt.savefig('figs/big_hg_2.svg', dpi=600)\n", - "plt.savefig('figs/big_hg_2.eps', dpi=600)\n", - "plt.savefig('figs/big_hg_2.pdf', dpi=600)\n", - "plt.savefig('figs/big_hg_2.png', dpi=600)" + "big_hg2.draw(v_label=big_v_label_2, v_color=v_color_2, e_color=e_color_2)\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "collapsed": false, "pycharm": { @@ -121,7 +111,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -134,16 +124,12 @@ "big_v_label_3 = [str(i) for i in range(big_hg3.num_v)]\n", "e_color_3 = ['g'] * 30 \n", "v_color_3 = ['g'] * 30 # 节点和边的颜色数平分\n", - "big_hg3.draw(v_label=big_v_label_3, v_color=v_color_3, e_color=e_color_3)\n", - "plt.savefig('figs/big_hg_3.svg', dpi=600)\n", - "plt.savefig('figs/big_hg_3.eps', dpi=600)\n", - "plt.savefig('figs/big_hg_3.png', dpi=600)\n", - "plt.savefig('figs/big_hg_3.png', dpi=600)" + "big_hg3.draw(v_label=big_v_label_3, v_color=v_color_3, e_color=e_color_3)\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "pycharm": { "name": "#%%\n" @@ -154,29 +140,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Multilayer hypergraph constructing...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:00" ] @@ -210,11 +174,7 @@ "big_v_label = [str(i) for i in range(big_mhg.num_v)]\n", "e_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30\n", "v_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30 # 节点和边的颜色数平分\n", - "big_mhg.draw(v_label=big_v_label, v_color=v_color, e_color=e_color)\n", - "plt.savefig('figs/large_hg.svg', dpi=600)\n", - "plt.savefig('figs/large_hg.eps', dpi=600)\n", - "plt.savefig('figs/large_hg.pdf', dpi=600)\n", - "plt.savefig('figs/large_hg.png', dpi=600)" + "big_mhg.draw(v_label=big_v_label, v_color=v_color, e_color=e_color)\n" ] }, { @@ -230,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": { "pycharm": { "name": "#%%\n" @@ -241,29 +201,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Multilayer hypergraph constructing...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:00" ] @@ -299,15 +237,12 @@ "small_v_label = [str(i) for i in range(small_mhg.num_v)]\n", "e_color = ['r'] * 3 + ['b'] * 3\n", "v_color = ['r'] * 5 + ['b'] * 5\n", - "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)\n", - "plt.savefig('figs/small_hg.svg', dpi=600)\n", - "plt.savefig('figs/small_hg.eps', dpi=600)\n", - "plt.savefig('figs/small_hg.pdf', dpi=600)" + "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)\n" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": { "pycharm": { "name": "#%%\n" @@ -318,7 +253,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "MultilayerHypergraph(num_v=10, num_e=8, num_layers=2, layers_list=[Hypergraph(num_v=5, num_e=3), Hypergraph(num_v=5, num_e=3)], prob_inner_layer_connect=0)\n" + "Hypergraph(num_v=10, num_e=8)\n" ] } ], @@ -329,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": { "pycharm": { "name": "#%%\n" @@ -338,7 +273,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -356,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": { "pycharm": { "name": "#%%\n" @@ -367,29 +302,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Multilayer hypergraph constructing...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:00" ] @@ -431,7 +344,7 @@ ], "metadata": { "kernelspec": { - "display_name": "dhg_cuda117", + "display_name": "use_dhg", "language": "python", "name": "python3" }, diff --git a/tests/structure/test_multilayer_hypergraph.py b/tests/structure/test_multilayer_hypergraph.py index 24bd98f..62110b0 100644 --- a/tests/structure/test_multilayer_hypergraph.py +++ b/tests/structure/test_multilayer_hypergraph.py @@ -1,62 +1,64 @@ import torch import pytest -import numpy as np -from dhg import Hypergraph, MultilayerHypergraph -import matplotlib.pyplot as plt -# from dhg.random.hypergraph import hypergraph_Gnm +from dhg import Hypergraph, MultilayerHypergraph -@pytest.fixture() +@pytest.fixture def g1(): - e_list = [(0, 1, 2, 5), (0, 1), (2, 3, 4), (3, 2, 4)] - g = Hypergraph(6, e_list) - return g + return Hypergraph(6, [(0, 1, 2, 5), (0, 1), (2, 3, 4), (3, 2, 4)]) -@pytest.fixture() +@pytest.fixture def g2(): - e_list = [(1, 2, 3), (0, 1, 3), (0, 1), (2, 4, 3), (2, 3)] - e_weight = [0.5, 1, 0.5, 1, 0.5] - g = Hypergraph(5, e_list, e_weight) - return g - - -def test_save(g1, tmp_path): - from dhg import load_structure - - g1.save(tmp_path / "g1") - g2 = load_structure(tmp_path / "g1") - - for e1, e2 in zip(g1.e[0], g2.e[0]): - assert e1 == e2 - for w1, w2 in zip(g1.e[1], g2.e[1]): - assert w1 == w2 - - -# test adjacency matrix -def test_adjacency_matrix(g1): - adj = g1.A - assert adj.shape == (6, 6) - assert np.allclose(adj[0, 1], 1) - assert np.allclose(adj[0, 2], 1) - assert np.allclose(adj[0, 3], 0) - assert np.allclose(adj[0, 4], 0) - assert np.allclose(adj[0, 5], 1) -# test construction -def test_construct_multilayer_hypergraph(): - g1 = g1() - g2 = g2() - + return Hypergraph(5, [(1, 2, 3), (0, 1, 3), (0, 1), (2, 4, 3), (2, 3)]) + + +def test_construct_multilayer_hypergraph(g1, g2): mhg = MultilayerHypergraph(11, 2, [g1, g2]) + assert mhg.num_layers == 2 - assert mhg.layers_list[0] == g1 - assert mhg.layers_list[1] == g2 + assert mhg.layers_list == [g1, g2] assert mhg.num_v == 11 assert mhg.prob_inner_layer_connect == 0 - assert mhg.device == torch.device('cpu') + assert mhg.device == torch.device("cpu") + + combined = mhg.construct_multi_layer_hypergraph() + assert type(combined) is Hypergraph + assert combined.num_v == 11 + assert combined.num_e == g1.num_e + g2.num_e + -def test_draw(mhg): - mhg.draw() - plt.show() +def test_offsets_are_local_and_repeatable(g1, g2): + mhg = MultilayerHypergraph(11, 2, [g1, g2]) + + assert mhg.node_layer_list() == [list(g1.v), [v + 6 for v in g2.v]] + first = mhg._inter_layer_connect() + second = mhg._inter_layer_connect() + assert first == second + assert mhg.construct_multi_layer_hypergraph().num_e == g1.num_e + g2.num_e + + +def test_select_nodes_accepts_range(monkeypatch): + monkeypatch.setattr( + "dhg.structure.hypergraphs.multilayer_hypergraph.random.random", + lambda: 0, + ) + assert MultilayerHypergraph.select_nodes(range(3), 1.0) == [0, 1, 2] + + +def test_mapping_save_writes_once(g1, g2, tmp_path): + source_a = tmp_path / "a.txt" + source_b = tmp_path / "b.txt" + source_a.write_text("geneA\t1\ngeneB\t2\n", encoding="utf-8") + source_b.write_text("geneA\t7\ngeneB\t8\n", encoding="utf-8") + output = tmp_path / "merged.txt" + mhg = MultilayerHypergraph(11, 2, [g1, g2]) + assert mhg.load_interlayer_mapping( + [str(source_a), str(source_b)], True, output + ) == [(1, 7), (2, 8)] + assert output.read_text(encoding="utf-8").splitlines() == [ + "geneA [1, 7]", + "geneB [2, 8]", + ] \ No newline at end of file