Download annotations/annotation_42/HTML/transfer_learning/chem/batch.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 9.17 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/transfer_learning/chem/batch.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_42/HTML/transfer_learning/chem/batch.py
-
curl -L -o batch.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/transfer_learning/chem/batch.py
9.17 kB
| import torch | |
| from torch_geometric.data import Data, Batch | |
| class BatchMasking(Data): | |
| r"""A plain old python object modeling a batch of graphs as one big | |
| (dicconnected) graph. With :class:`torch_geometric.data.Data` being the | |
| base class, all its methods can also be used here. | |
| In addition, single graphs can be reconstructed via the assignment vector | |
| :obj:`batch`, which maps each node to its respective graph identifier. | |
| """ | |
| def __init__(self, batch=None, **kwargs): | |
| super(BatchMasking, self).__init__(**kwargs) | |
| self.batch = batch | |
| def from_data_list(data_list): | |
| r"""Constructs a batch object from a python list holding | |
| :class:`torch_geometric.data.Data` objects. | |
| The assignment vector :obj:`batch` is created on the fly.""" | |
| keys = [set(data.keys) for data in data_list] | |
| keys = list(set.union(*keys)) | |
| assert 'batch' not in keys | |
| batch = BatchMasking() | |
| for key in keys: | |
| batch[key] = [] | |
| batch.batch = [] | |
| cumsum_node = 0 | |
| cumsum_edge = 0 | |
| for i, data in enumerate(data_list): | |
| num_nodes = data.num_nodes | |
| batch.batch.append(torch.full((num_nodes, ), i, dtype=torch.long)) | |
| for key in data.keys: | |
| item = data[key] | |
| if key in ['edge_index', 'masked_atom_indices']: | |
| item = item + cumsum_node | |
| elif key == 'connected_edge_indices': | |
| item = item + cumsum_edge | |
| batch[key].append(item) | |
| cumsum_node += num_nodes | |
| cumsum_edge += data.edge_index.shape[1] | |
| for key in keys: | |
| batch[key] = torch.cat( | |
| batch[key], dim=data_list[0].cat_dim(key, batch[key][0])) | |
| batch.batch = torch.cat(batch.batch, dim=-1) | |
| return batch.contiguous() | |
| def cumsum(self, key, item): | |
| r"""If :obj:`True`, the attribute :obj:`key` with content :obj:`item` | |
| should be added up cumulatively before concatenated together. | |
| .. note:: | |
| This method is for internal use only, and should only be overridden | |
| if the batch concatenation process is corrupted for a specific data | |
| attribute. | |
| """ | |
| return key in ['edge_index', 'face', 'masked_atom_indices', 'connected_edge_indices'] | |
| def num_graphs(self): | |
| """Returns the number of graphs in the batch.""" | |
| return self.batch[-1].item() + 1 | |
| class BatchAE(Data): | |
| r"""A plain old python object modeling a batch of graphs as one big | |
| (dicconnected) graph. With :class:`torch_geometric.data.Data` being the | |
| base class, all its methods can also be used here. | |
| In addition, single graphs can be reconstructed via the assignment vector | |
| :obj:`batch`, which maps each node to its respective graph identifier. | |
| """ | |
| def __init__(self, batch=None, **kwargs): | |
| super(BatchAE, self).__init__(**kwargs) | |
| self.batch = batch | |
| def from_data_list(data_list): | |
| r"""Constructs a batch object from a python list holding | |
| :class:`torch_geometric.data.Data` objects. | |
| The assignment vector :obj:`batch` is created on the fly.""" | |
| keys = [set(data.keys) for data in data_list] | |
| keys = list(set.union(*keys)) | |
| assert 'batch' not in keys | |
| batch = BatchAE() | |
| for key in keys: | |
| batch[key] = [] | |
| batch.batch = [] | |
| cumsum_node = 0 | |
| for i, data in enumerate(data_list): | |
| num_nodes = data.num_nodes | |
| batch.batch.append(torch.full((num_nodes, ), i, dtype=torch.long)) | |
| for key in data.keys: | |
| item = data[key] | |
| if key in ['edge_index', 'negative_edge_index']: | |
| item = item + cumsum_node | |
| batch[key].append(item) | |
| cumsum_node += num_nodes | |
| for key in keys: | |
| batch[key] = torch.cat( | |
| batch[key], dim=batch.cat_dim(key)) | |
| batch.batch = torch.cat(batch.batch, dim=-1) | |
| return batch.contiguous() | |
| def num_graphs(self): | |
| """Returns the number of graphs in the batch.""" | |
| return self.batch[-1].item() + 1 | |
| def cat_dim(self, key): | |
| return -1 if key in ["edge_index", "negative_edge_index"] else 0 | |
| class BatchSubstructContext(Data): | |
| r"""A plain old python object modeling a batch of graphs as one big | |
| (dicconnected) graph. With :class:`torch_geometric.data.Data` being the | |
| base class, all its methods can also be used here. | |
| In addition, single graphs can be reconstructed via the assignment vector | |
| :obj:`batch`, which maps each node to its respective graph identifier. | |
| """ | |
| """ | |
| Specialized batching for substructure context pair! | |
| """ | |
| def __init__(self, batch=None, **kwargs): | |
| super(BatchSubstructContext, self).__init__(**kwargs) | |
| self.batch = batch | |
| def from_data_list(data_list): | |
| r"""Constructs a batch object from a python list holding | |
| :class:`torch_geometric.data.Data` objects. | |
| The assignment vector :obj:`batch` is created on the fly.""" | |
| #keys = [set(data.keys) for data in data_list] | |
| #keys = list(set.union(*keys)) | |
| #assert 'batch' not in keys | |
| batch = BatchSubstructContext() | |
| keys = ["center_substruct_idx", "edge_attr_substruct", "edge_index_substruct", "x_substruct", "overlap_context_substruct_idx", "edge_attr_context", "edge_index_context", "x_context"] | |
| for key in keys: | |
| #print(key) | |
| batch[key] = [] | |
| #batch.batch = [] | |
| #used for pooling the context | |
| batch.batch_overlapped_context = [] | |
| batch.overlapped_context_size = [] | |
| cumsum_main = 0 | |
| cumsum_substruct = 0 | |
| cumsum_context = 0 | |
| i = 0 | |
| for data in data_list: | |
| #If there is no context, just skip!! | |
| if hasattr(data, "x_context"): | |
| num_nodes = data.num_nodes | |
| num_nodes_substruct = len(data.x_substruct) | |
| num_nodes_context = len(data.x_context) | |
| #batch.batch.append(torch.full((num_nodes, ), i, dtype=torch.long)) | |
| batch.batch_overlapped_context.append(torch.full((len(data.overlap_context_substruct_idx), ), i, dtype=torch.long)) | |
| batch.overlapped_context_size.append(len(data.overlap_context_substruct_idx)) | |
| ###batching for the main graph | |
| #for key in data.keys: | |
| # if not "context" in key and not "substruct" in key: | |
| # item = data[key] | |
| # item = item + cumsum_main if batch.cumsum(key, item) else item | |
| # batch[key].append(item) | |
| ###batching for the substructure graph | |
| for key in ["center_substruct_idx", "edge_attr_substruct", "edge_index_substruct", "x_substruct"]: | |
| item = data[key] | |
| item = item + cumsum_substruct if batch.cumsum(key, item) else item | |
| batch[key].append(item) | |
| ###batching for the context graph | |
| for key in ["overlap_context_substruct_idx", "edge_attr_context", "edge_index_context", "x_context"]: | |
| item = data[key] | |
| item = item + cumsum_context if batch.cumsum(key, item) else item | |
| batch[key].append(item) | |
| cumsum_main += num_nodes | |
| cumsum_substruct += num_nodes_substruct | |
| cumsum_context += num_nodes_context | |
| i += 1 | |
| for key in keys: | |
| batch[key] = torch.cat( | |
| batch[key], dim=batch.cat_dim(key)) | |
| #batch.batch = torch.cat(batch.batch, dim=-1) | |
| batch.batch_overlapped_context = torch.cat(batch.batch_overlapped_context, dim=-1) | |
| batch.overlapped_context_size = torch.LongTensor(batch.overlapped_context_size) | |
| return batch.contiguous() | |
| def cat_dim(self, key): | |
| return -1 if key in ["edge_index", "edge_index_substruct", "edge_index_context"] else 0 | |
| def cumsum(self, key, item): | |
| r"""If :obj:`True`, the attribute :obj:`key` with content :obj:`item` | |
| should be added up cumulatively before concatenated together. | |
| .. note:: | |
| This method is for internal use only, and should only be overridden | |
| if the batch concatenation process is corrupted for a specific data | |
| attribute. | |
| """ | |
| return key in ["edge_index", "edge_index_substruct", "edge_index_context", "overlap_context_substruct_idx", "center_substruct_idx"] | |
| def num_graphs(self): | |
| """Returns the number of graphs in the batch.""" | |
| return self.batch[-1].item() + 1 | |