hjxdl 0.0.1__py3-none-any.whl

hdl/models/utils.py

@@ -0,0 +1,83 @@
+import typing as t
+
+import torch
+from torch import nn
+
+
+def save_model(
+    model: t.Union[nn.Module, nn.DataParallel],
+    save_dir: str = "./model.ckpt",
+    epoch: int = 0,
+    optimizer: torch.optim.Optimizer = None,
+    loss: float = None,
+) -> None:
+    if isinstance(model, nn.DataParallel):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    if optimizer is None:
+        optim_params = None
+    else:
+        optim_params = optimizer.state_dict()
+    torch.save(
+        {
+            'init_args': model.init_args,
+            'epoch': epoch,
+            'model_state_dict': state_dict,
+            'optimizer_state_dict': optim_params,
+            'loss': loss,
+        },
+        save_dir
+    )
+
+
+def load_model(
+    save_dir: str,
+    model_name: str = None,
+    model: t.Union[nn.Module, nn.DataParallel] = None,
+    optimizer: torch.optim.Optimizer = None,
+    train: bool = False,
+) -> t.Tuple[
+    t.Union[nn.Module, nn.DataParallel],
+    torch.optim.Optimizer,
+    int,
+    float
+]:
+    from .model_dict import MODEL_DICT
+    checkpoint = torch.load(save_dir)
+    if model is None:
+        init_args = checkpoint['init_args']
+        assert model_name is not None
+        model = MODEL_DICT[model_name](**init_args)
+        model.load_state_dict( 
+            checkpoint['model_state_dict'], 
+        )
+    
+    elif isinstance(model, nn.DataParallel):
+        state_dict = checkpoint['model_state_dict']
+        from collections import OrderedDict
+        new_state_dict = OrderedDict()
+
+        for k, v in state_dict.items():
+            if 'module' not in k:
+                k = 'module.' + k
+            else:
+                k = k.replace('features.module.', 'module.features.')
+            new_state_dict[k] = v
+        model.load_state_dict(new_state_dict)
+    else:
+        model.load_state_dict( 
+            checkpoint['model_state_dict'], 
+        )
+    
+    if optimizer is not None:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    epoch = checkpoint.get('epoch', 0)
+    loss = checkpoint.get('loss', 0.0)
+
+    if train:
+        model.train()
+    else:
+        model.eval()
+
+    return model, optimizer, epoch, loss

hdl/ops/utils.py

@@ -0,0 +1,42 @@
+import typing as t
+
+# import torch
+from torch import nn
+
+
+__all__ = [
+    'get_activation'
+]
+
+
+def get_activation(
+    name: str,
+    **kwargs
+) -> t.Callable:
+    """ Get activation module by name
+    Args:
+        name (str): The name of the activation function (relu, elu, selu)
+        args, kwargs: Other parameters
+    Returns:
+        nn.Module: The activation module
+    """
+    name = name.lower()
+    if name == 'relu':
+        inplace = kwargs.get('inplace', False)
+        return nn.ReLU(inplace=inplace)
+    elif name == 'elu':
+        alpha = kwargs.get('alpha', 1.)
+        inplace = kwargs.get('inplace', False)
+        return nn.ELU(alpha=alpha, inplace=inplace)
+    elif name == 'selu':
+        inplace = kwargs.get('inplace', False)
+        return nn.SELU(inplace=inplace)
+    elif name == 'softmax':
+        dim = kwargs.get('dim', -1)
+        return nn.Softmax(dim=dim)
+    elif name == 'sigmoid':
+        return nn.Sigmoid()
+    elif name == 'none':
+        return 
+    else:
+        raise ValueError('Activation not implemented')

hdl/optims/nadam.py

@@ -0,0 +1,86 @@
+import torch as torch
+from torch import optim
+
+
+class Nadam(optim.Adam):
+    """
+    Adaptive moment with Nesterov gradients.
+
+    http://cs229.stanford.edu/proj2015/054_report.pdf
+
+    Parameters
+    ----------
+    params
+        iterable of parameters to optimize or dicts defining
+        parameter groups
+    lr
+        learning rate (default: 1e-3)
+    betas
+        coefficients used for computing
+        running averages of gradient and its square (default: (0.9, 0.999))
+    eps
+        term added to the denominator to improve
+        numerical stability (default: 1e-8)
+    weight_decay
+        weight decay (L2 penalty) (default: 0)
+    decay
+        a decay scheme for `betas[0]`.
+        Default: :math:`\\beta * (1 - 0.5 * 0.96^{\\frac{t}{250}})`
+        where `t` is the training step.
+    """
+
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0,
+                 decay=lambda x, t: x * (1. - .5 * .96 ** (t / 250.))):
+        super().__init__(params, lr, betas, eps, weight_decay)
+        self.decay = decay
+
+    def step(self, closure=None):
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad.data
+                if grad.is_sparse:
+                    raise RuntimeError('NAdam does not support sparse gradients, please consider SparseAdam instead')
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    # Exponential moving average of gradient values
+                    state['exp_avg'] = torch.zeros_like(p.data)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p.data)
+                    # Beta1 accumulation
+                    state['beta1_cum'] = 1.
+
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+                beta1, beta2 = group['betas']
+
+                state['step'] += 1
+
+                if group['weight_decay'] != 0:
+                    grad.add_(group['weight_decay'], p.data)
+
+                beta1_t = self.decay(beta1, state['step'])
+                beta1_tp1 = self.decay(beta1, state['step'] + 1.)
+                beta1_cum = state['beta1_cum'] * beta1_t
+
+                g_hat_t = grad / (1. - beta1_cum)
+                exp_avg.mul_(beta1).add_(1. - beta1, grad)
+                m_hat_t = exp_avg / (1. - beta1_cum * beta1_tp1)
+
+                exp_avg_sq.mul_(beta2).addcmul_(1. - beta2, grad, grad)
+                v_hat_t = exp_avg_sq / (1. - beta2 ** state['step'])
+                m_bar_t = (1. - beta1) * g_hat_t + beta1_tp1 * m_hat_t
+
+                denom = v_hat_t.sqrt().add_(group['eps'])
+                p.data.addcdiv_(-group['lr'], m_bar_t, denom)
+                state['beta1_cum'] = beta1_cum
+
+        return loss

hdl/utils/chemical_tools/__init__.py

@@ -0,0 +1,2 @@
+from .sdf import sdf2df
+from .query_info import query_a_compound

hdl/utils/chemical_tools/query_info.py

@@ -0,0 +1,149 @@
+import re
+
+import cirpy
+import pubchempy as pcp
+# from rdkit import Chem
+import molvs as mv
+from psycopg import sql
+
+from hdl.utils.database_tools.connect import connect_by_infofile
+
+
+def query_from_cir(query_name: str):
+    smiles = None
+    # cas_list = []
+    # name_list = []
+    
+    cas_list = cirpy.resolve(query_name, 'cas')
+    if cas_list is None or not cas_list:
+        cas_list = []
+    if isinstance(cas_list, str):
+        cas_list = [cas_list]
+
+    name_list = cirpy.resolve(query_name, 'names')
+    if name_list is None or not name_list:
+        name_list = []
+    if isinstance(name_list, str):
+        name_list = [name_list]
+
+    smiles = cirpy.resolve(query_name, 'smiles')
+    try:
+        smiles = mv.standardize_smiles(smiles)
+    except Exception as e:
+        print(e)
+
+    return smiles, cas_list, name_list
+
+
+def query_from_pubchem(query_name: str):
+    results = pcp.get_compounds(query_name, 'name')
+    smiles = None
+    name_list = set()
+    cas_list = set()
+
+    if any(results):
+        try:
+            smiles = mv.standardize_smiles(results[0].canonical_smiles)
+        except Exception as e:
+            smiles = results[0].canonical_smiles
+            print(smiles)
+            print(e)
+        for compound in results:
+            name_list.update(set(compound.synonyms))
+            for syn in compound.synonyms:
+                match = re.match('(\d{2,7}-\d\d-\d)', syn)
+                if match:
+                    cas_list.add(match.group(1))
+        
+        cas_list = list(cas_list)
+        name_list = list(name_list)
+
+    return smiles, cas_list, name_list
+
+
+def query_a_compound(
+    query_name: str,
+    connect_info: str,
+    by: str = 'name',
+    log_file: str = './err.log'
+):
+    fei = None
+    found = False  
+
+    query_name = query_name.lower()
+    
+    by = 'name'
+    table = by + '_maps'
+    # query_name = 'adipic acid'
+    query = sql.SQL(
+        "select fei from {table} where {by} = %s"
+    ).format(
+        table=sql.Identifier(table),
+        by=sql.Identifier(by)
+    )
+    conn = connect_by_infofile(connect_info)
+    
+    cur = conn.execute(query, [query_name]).fetchone()
+
+    if cur is not None:
+        fei = cur[0]
+        found = True
+        return fei
+ 
+    if not found:
+        try:
+            smiles, cas_list, name_list = query_from_pubchem(query_name) 
+        except Exception as e:
+            print(e)
+            smiles, cas_list, name_list = None, [], []
+        if smiles is not None:
+            found = True
+        else:
+            try:
+                smiles, cas_list, name_list = query_from_cir(query_name)
+            except Exception as e:
+                print(e)
+                smiles, cas_list, name_list = None, [], []
+            if smiles is not None:
+                found = True
+    
+    if not found:
+        with open(log_file, 'a') as f:
+            f.write(query_name)
+            f.write('\n')
+        return
+        # raise ValueError('给的啥破玩意儿查都查不着！')
+    else:
+        query_compound = sql.SQL(
+            "select fei from compounds where smiles = %s"
+        )
+        cur = conn.execute(query_compound, [smiles]).fetchone()
+        if cur is not None:
+            fei = cur[0]
+        elif any(cas_list):
+            fei = cas_list[0]
+            insert_compounds_sql = sql.SQL(
+                "INSERT INTO compounds (fei, smiles) VALUES (%s, %s) ON CONFLICT (fei) DO NOTHING"
+            )
+            conn.execute(insert_compounds_sql, [fei, smiles])
+        for cas in cas_list:
+            insert_cas_map_sql = sql.SQL(
+                "INSERT INTO cas_maps (fei, cas) VALUES (%s, %s) ON CONFLICT (cas) DO NOTHING"
+            )
+            try:
+                conn.execute(insert_cas_map_sql, [fei, cas])
+            except Exception as e:
+                print(e)
+        for name in name_list:
+            insert_name_map_sql = sql.SQL(
+                "INSERT INTO name_maps (fei, name) VALUES (%s, %s) ON CONFLICT (name) DO NOTHING"
+            ) 
+            try:
+                conn.execute(insert_name_map_sql, [fei, name.lower()])
+            except Exception as e:
+                print(e)
+
+    conn.commit()
+    conn.close()
+
+    return fei

hdl/utils/chemical_tools/sdf.py

@@ -0,0 +1,20 @@
+from rdkit import Chem
+import pandas as pd
+
+
+def sdf2df(
+    sdf_file,
+    id_col: str = 'Molecule Name',
+    target_col: str = 'Average △G (kcal/mol)'
+):
+    supp = Chem.SDMolSupplier(sdf_file)
+    mol_dict_list = []
+    for mol in supp:
+        smiles = Chem.MolToSmiles(mol)
+        mol_dict = mol.GetPropsAsDict()
+        mol_dict['smiles'] = smiles
+        mol_dict_list.append(mol_dict)
+        mol_dict['y'] = mol_dict.pop(target_col)
+        mol_dict['name'] = mol_dict.pop(id_col)
+    df = pd.DataFrame(mol_dict_list)
+    return df

hdl/utils/database_tools/connect.py

@@ -0,0 +1,28 @@
+import psycopg
+
+
+def connect_by_infofile(info_file: str) -> psycopg.Connection:
+    """Create a postgres connection
+
+    Args:
+        info_file (str): 
+            the path of the connection info like
+            host=127.0.0.1 dbname=dbname port=5432 user=postgres password=lala
+
+    Returns:
+        psycopg.Connection: 
+            the connection instance should be closed after committing.
+    """
+    conn = psycopg.connect(
+        open(info_file).readline()
+    )
+    return conn
+# with psycopg.connect(
+#     open('./conn.info').readline()
+# ) as conn:
+#     cur = conn.execute('select * from name_maps;')
+#     cur.fetchone()
+#     for record in cur:
+#         print(record)
+#     conn.commit()
+#     conn.close()

hdl/utils/general/glob.py

@@ -0,0 +1,21 @@
+import subprocess
+
+
+def get_num_lines(file):
+    num_lines = subprocess.check_output(
+        ['wc', '-l', file]
+    ).split()[0]
+    return int(num_lines)
+
+
+def str_from_line(file, line, split=False):
+    smi = subprocess.check_output(
+        # ['sed','-n', f'{str(i+1)}p', file]
+        ["sed", f"{str(line + 1)}q;d", file]
+    )
+    if isinstance(smi, bytes):
+        smi = smi.decode().strip()
+    if split:
+        if ' ' or '\t' in smi:
+            smi = smi.split()[0]
+    return smi

hdl/utils/schedulers/norm_lr.py

@@ -0,0 +1,108 @@
+from typing import List, Union
+import numpy as np
+
+from torch.optim import Optimizer
+from torch.optim.lr_scheduler import _LRScheduler
+
+
+class NoamLR(_LRScheduler):
+    """
+    Noam learning rate scheduler with piecewise linear increase and exponential decay.
+    The learning rate increases linearly from init_lr to max_lr over the course of
+    the first warmup_steps (where warmup_steps = warmup_epochs * steps_per_epoch).
+    Then the learning rate decreases exponentially from max_lr to final_lr over the
+    course of the remaining total_steps - warmup_steps (where total_steps =
+    total_epochs * steps_per_epoch). This is roughly based on the learning rate
+    schedule from Attention is All You Need, section 5.3 (https://arxiv.org/abs/1706.03762).
+    """
+    def __init__(self,
+                 optimizer: Optimizer,
+                 warmup_epochs: List[Union[float, int]],
+                 total_epochs: List[int],
+                 steps_per_epoch: int,
+                 init_lr: List[float],
+                 max_lr: List[float],
+                 final_lr: List[float]):
+        """
+        Initializes the learning rate scheduler.
+        :param optimizer: A PyTorch optimizer.
+        :param warmup_epochs: The number of epochs during which to linearly increase the learning rate.
+        :param total_epochs: The total number of epochs.
+        :param steps_per_epoch: The number of steps (batches) per epoch.
+        :param init_lr: The initial learning rate.
+        :param max_lr: The maximum learning rate (achieved after warmup_epochs).
+        :param final_lr: The final learning rate (achieved after total_epochs).
+        """
+        assert len(optimizer.param_groups) == len(warmup_epochs) == len(total_epochs) == len(init_lr) == \
+               len(max_lr) == len(final_lr)
+
+        self.num_lrs = len(optimizer.param_groups)
+
+        self.optimizer = optimizer
+        self.warmup_epochs = np.array(warmup_epochs)
+        self.total_epochs = np.array(total_epochs)
+        self.steps_per_epoch = steps_per_epoch
+        self.init_lr = np.array(init_lr)
+        self.max_lr = np.array(max_lr)
+        self.final_lr = np.array(final_lr)
+
+        self.current_step = 0
+        self.lr = init_lr
+        self.warmup_steps = (self.warmup_epochs * self.steps_per_epoch).astype(int)
+        self.total_steps = self.total_epochs * self.steps_per_epoch
+        self.linear_increment = (self.max_lr - self.init_lr) / self.warmup_steps
+
+        self.exponential_gamma = (self.final_lr / self.max_lr) ** (1 / (self.total_steps - self.warmup_steps))
+
+        super(NoamLR, self).__init__(optimizer)
+
+    def get_lr(self) -> List[float]:
+        """Gets a list of the current learning rates."""
+        return list(self.lr)
+
+    def step(self, current_step: int = None):
+        """
+        Updates the learning rate by taking a step.
+        :param current_step: Optionally specify what step to set the learning rate to.
+        If None, current_step = self.current_step + 1.
+        """
+        if current_step is not None:
+            self.current_step = current_step
+        else:
+            self.current_step += 1
+
+        for i in range(self.num_lrs):
+            if self.current_step <= self.warmup_steps[i]:
+                self.lr[i] = self.init_lr[i] + self.current_step * self.linear_increment[i]
+            elif self.current_step <= self.total_steps[i]:
+                self.lr[i] = self.max_lr[i] * (self.exponential_gamma[i] ** (self.current_step - self.warmup_steps[i]))
+            else:  # theoretically this case should never be reached since training should stop at total_steps
+                self.lr[i] = self.final_lr[i]
+
+            self.optimizer.param_groups[i]['lr'] = self.lr[i]
+
+
+def build_lr_scheduler(
+    optimizer: Optimizer,
+    warmup_epochs: int,
+    n_epochs: int,
+    steps_per_epoch: int,
+    lr: float,
+) -> _LRScheduler:
+    """
+    Builds a learning rate scheduler.
+    :param optimizer: The Optimizer whose learning rate will be scheduled.
+    :param args: Arguments.
+    :param train_data_size: The size of the training dataset.
+    :return: An initialized learning rate scheduler.
+    """
+    # Learning rate scheduler
+    return NoamLR(
+        optimizer=optimizer,
+        warmup_epochs=[warmup_epochs],
+        total_epochs=[n_epochs],
+        steps_per_epoch=steps_per_epoch,  # train_data_size // args.batch_size,
+        init_lr=[lr / 10],
+        max_lr=[lr],
+        final_lr=[lr / 10]
+    )

hjxdl-0.0.1.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: hjxdl
+Version: 0.0.1
+Summary: A collection of functions for Jupyter notebooks
+Home-page: https://github.com/huluxiaohuowa/hdl
+Author: Jianxing Hu
+Author-email: j.hu@pku.edu.cn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# DL framework by Jianxing
+
+```bash
+git clone git@github.com:huluxiaohuowa/hdl.git
+python setup.py install
+```

hjxdl-0.0.1.dist-info/RECORD

@@ -0,0 +1,91 @@
+hdl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/_version.py,sha256=pMnmqZnpVmaqR5nqHztNWzbbtb1oy5bPN_v7uhOH8K8,411
+hdl/args/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/args/loss_args.py,sha256=s7YzSdd7IjD24rZvvOrxLLFqMZQb9YylxKeyelSdrTk,70
+hdl/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/al/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/al/al.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/al/dispatcher.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/al/feedback.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/explain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/explain/shapley.py,sha256=6dPc_ICPgvllT8YtFxe9Ds-TVccsXr2M0lP4zKxGHQA,12436
+hdl/controllers/explain/subgraphx.py,sha256=2lxdmKlveyxWpYf2AdTvjm_C578WH-_z1fqhiHOzYXQ,38202
+hdl/controllers/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/controllers/train/rxn_train.py,sha256=G1MTRrcP-g9ohzl7tbGM1tYd9HAdcM-3_wHQtRYg4LE,4876
+hdl/controllers/train/train.py,sha256=K7UjerhMFks9gQINQtUNXfGBN-XejmJZs0Mqzd7k5rU,1637
+hdl/controllers/train/train_ginet.py,sha256=KFGIMwCF62HuuFCQcz5Vr394Lf0kkgOT9x_0pvMyVmU,8561
+hdl/controllers/train/trainer_base.py,sha256=SZpa-4aV9ptKf4wgKVTNqqy4yJnLPOaEUX56LE28u74,4012
+hdl/controllers/train/trainer_iterative.py,sha256=ydUJWuAvvfjosGBa4MvBeqqoNB6tlB4WWprBOXu9vG4,11803
+hdl/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/to_mols.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/base_dataset.py,sha256=qPLCCpIV-9dRqXf3MuyjCHt5QAxB2v1lUMtyo3IJ0V8,2664
+hdl/data/dataset/utils.py,sha256=tAh-a05Ireu6TiY89HHZ3WcLOz_Th8Cz0-lwlslklAM,1071
+hdl/data/dataset/fp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/fp/fp_dataset.py,sha256=ei7M7xRL81hzX4r7ybxupkGE0Oj2dTXxCTgDYEWgtVQ,4033
+hdl/data/dataset/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/graph/chiral.py,sha256=Tyz9-iBWoKESrYcnK6K0rif3A1SFcNMm9hbLfCmCVUA,1985
+hdl/data/dataset/graph/gin.py,sha256=To-wvp-u-VXK6w3W3CohqcSCEfMZ7grqZQzr9KiEZQM,8848
+hdl/data/dataset/graph/molnet.py,sha256=8VsKO3CDXwmq-3tlOFQLVIpxwoftAxI4WS9YtnOcI4Y,12806
+hdl/data/dataset/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/loaders/chiral_graph.py,sha256=efPpN5ovUqUhIPcPnL0zADD-zxaG8HRGD4KPwA_vbS8,2239
+hdl/data/dataset/loaders/general.py,sha256=eObFlDsIfoiqJkeZHpJ4-cFuFCUfDbc2tfZe1z8qm70,532
+hdl/data/dataset/loaders/spliter.py,sha256=5-OFKEbASsgaGaaYerNgRXm1WFRwLm_aZ-AZ0LefJ4U,3142
+hdl/data/dataset/loaders/collate_funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/loaders/collate_funcs/fp.py,sha256=nch2UjodF9Of7fTc61j7Td1yBhYPhAfVmrA_F3K_LV0,1436
+hdl/data/dataset/loaders/collate_funcs/rxn.py,sha256=LdwheQfilB9Obc7407nWgpWp7aGFFegTlYBeY20l77Y,860
+hdl/data/dataset/samplers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/samplers/chiral.py,sha256=ZS83kg5e2gdHVGgIuCjCepDwk2SKqWDgJawH37oXy78,463
+hdl/data/dataset/seq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/data/dataset/seq/rxn_dataset.py,sha256=jfXFlR3ITAf0KwUfIevzUZHnLBnFYrL69Cc81EMv0x0,1668
+hdl/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/features/fp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/features/fp/features_generators.py,sha256=HbyS97i2I2mOcANdJMohs2okA1LlZmkG4ZIIX6Y9fr4,9017
+hdl/features/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/features/graph/featurization.py,sha256=QLbj33JsgO-OWarIC2HXQP7eMu8pd-GWmppZQj_tQ_k,10902
+hdl/features/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/features/utils/utils.py,sha256=aL4UAALblaw1w0AjK7MX8nSj9zwTmrp9CTLwJUX8ZtE,4225
+hdl/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/layers/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/layers/general/gp.py,sha256=no1P6i2nCa539b0I5S6hd2mC8CeW0Ds726GM0swwlzc,525
+hdl/layers/general/linear.py,sha256=d8NJwONVpIRr9malj1YGtK3rSgHzTMmSa-_eq46HGdI,18511
+hdl/layers/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/layers/graph/chiral_graph.py,sha256=tqYPCUK4S5beUnuGzsCPrUyXEouCTi5CtUv74vZ9tws,8551
+hdl/layers/graph/gcn.py,sha256=Eg-v672GQ3gBr4Sez3qARD2D95WAhFjC5i0j94IyFTo,397
+hdl/layers/graph/gin.py,sha256=RkG8bZA_GgV2bcxwi6vCvk29QVVB9rCFchT3YpTULw4,1627
+hdl/layers/graph/tetra.py,sha256=dKocIszOZh93ZVd0cznZ4AJGDYdoSFN6vcnCwIto6mI,5169
+hdl/layers/graph/transformer.py,sha256=ZT7OId-0-i5obeoB-SG0XzotA-C-OeYl1CloGltdy48,7959
+hdl/layers/sequential/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/metric_loss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/metric_loss/loss.py,sha256=s89G3h6A4GVrqj0UXAvcvyVzJPvIfZQ_FjD5f5J6nh4,2024
+hdl/metric_loss/metric.py,sha256=6fx1XOqtbekohgHZXJvLvnl73zictndCYoynJsy8Q-c,5030
+hdl/metric_loss/multi_label.py,sha256=XOONQZVfO3EhcpwwO6IeQP2MacW0qDkHcrh0oEoMk5M,1738
+hdl/metric_loss/nt_xent.py,sha256=CFPFf1mZ64SaAt5Q8DEFYU3AGSgcErCl49vOWIequLM,2476
+hdl/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/models/chiral_gnn.py,sha256=NDwSbyefev9SawKJf1DfnBUxOcHxZCFoL13rbXAh2oc,6026
+hdl/models/fast_transformer.py,sha256=tTBk6svXEdJDycQJtpGJMFudbVy2KJbrplSJUdvwofY,6594
+hdl/models/ginet.py,sha256=k8_j6uvZ4TJU5eshrZOBBLaIo4YmLUX3WPrvgEtTn3A,5311
+hdl/models/linear.py,sha256=brVYb1_Nq3IwPZ-i3ykS0JPYSxxmDb7QH1yaPMNDQJY,4523
+hdl/models/model_dict.py,sha256=uRh13nch7rab3DajnDR_usp_1R0b37WUgNoiqOobk-s,402
+hdl/models/norm_flows.py,sha256=nROlAaToUOtqi99_BPe6rlPHpUS38YFAtDll1xmGv5U,830
+hdl/models/optim_dict.py,sha256=xvefZwCGebIXhRLSbcoGa3WVUWW2kEEm0Gsgp8Q9SQw,231
+hdl/models/rxn.py,sha256=6MEkzjWEgWgl14EkdprvVtycX1q-xlYnXekM1ROKFL0,1557
+hdl/models/utils.py,sha256=OOdwZ7f5ciaEFNM9zouNpLxj8S8kGKsSIM0msnoJ3bQ,2221
+hdl/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/ops/utils.py,sha256=GIe95pJYVqOQQ91ELb1tfogVFzGg2VJdQmIFX8aHeyM,1053
+hdl/optims/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/optims/nadam.py,sha256=l9DFQaHwE-uE0a_oSQZcvaqMv7lzYd2x_nE9no4zz64,3046
+hdl/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/utils/chemical_tools/__init__.py,sha256=_QRNtVx0ieZZgSEsHndPFKm6XU3WXfRb7GYq-exe1nU,65
+hdl/utils/chemical_tools/query_info.py,sha256=wyQXwKSY_gBGVUNvYggHpYBtOLAtpYKq3PN5wqDb7Co,4204
+hdl/utils/chemical_tools/sdf.py,sha256=71PEqU0H885L6IeGHEa6n7ZLZThvMsZOVLuFG2wnoyM,542
+hdl/utils/database_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/utils/database_tools/connect.py,sha256=KUnVG-8raifEJ_N0b3c8LkTTIfn9NIyw8LX6qvpA3YU,723
+hdl/utils/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/utils/general/glob.py,sha256=8-RCnt6L297wMIfn34ZAMCsGCZUjHG3MGglGZI1cX0g,491
+hdl/utils/schedulers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdl/utils/schedulers/norm_lr.py,sha256=bDwCmdEK-WkgxQMFBiMuchv8Mm7C0-GZJ6usm-PQk14,4461
+hjxdl-0.0.1.dist-info/METADATA,sha256=w_oFdQOD0f8NHTb_8bVi7ypyO-lCZhHWqAMvGYADljo,525
+hjxdl-0.0.1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+hjxdl-0.0.1.dist-info/top_level.txt,sha256=-kxwTM5JPhylp06z3zAVO3w6_h7wtBfBo2zgM6YZoTk,4
+hjxdl-0.0.1.dist-info/RECORD,,

hjxdl-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+