torchani 0.6__tar.gz → 0.7__tar.gz

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani/__init__.py

@@ -30,11 +30,9 @@ from .aev import AEVComputer
 from . import utils
 from . import neurochem
 from . import models
+from . import optim
 from pkg_resources import get_distribution, DistributionNotFound
 import sys
-if sys.version_info[0] > 2:
-    from . import ignite
-    from . import data
 
 try:
     __version__ = get_distribution(__name__).version
@@ -43,10 +41,20 @@ except DistributionNotFound:
     pass
 
 __all__ = ['AEVComputer', 'EnergyShifter', 'ANIModel', 'Ensemble',
-           'ignite', 'utils', 'neurochem', 'data', 'models']
+           'utils', 'neurochem', 'models', 'optim']
 
 try:
     from . import ase  # noqa: F401
     __all__.append('ase')
 except ImportError:
     pass
+
+
+if sys.version_info[0] > 2:
+    try:
+        from . import ignite  # noqa: F401
+        __all__.append('ignite')
+        from . import data  # noqa: F401
+        __all__.append('data')
+    except ImportError:
+        pass

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani/ignite.py

@@ -4,7 +4,7 @@ from __future__ import absolute_import
 import torch
 from . import utils
 from torch.nn.modules.loss import _Loss
-from ignite.metrics import Metric, RootMeanSquaredError
+from ignite.metrics import Metric, RootMeanSquaredError, MeanAbsoluteError
 from ignite.contrib.metrics.regression import MaximumAbsoluteError
 
 
@@ -111,10 +111,15 @@ def RMSEMetric(key):
     return DictMetric(key, RootMeanSquaredError())
 
 
-def MAEMetric(key):
+def MaxAEMetric(key):
     """Create max absolute error metric on key."""
     return DictMetric(key, MaximumAbsoluteError())
 
 
+def MAEMetric(key):
+    """Create max absolute error metric on key."""
+    return DictMetric(key, MeanAbsoluteError())
+
+
 __all__ = ['Container', 'MSELoss', 'TransformedLoss', 'RMSEMetric',
-           'MAEMetric']
+           'MaxAEMetric']

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani/neurochem/__init__.py

@@ -8,7 +8,6 @@ import bz2
 import lark
 import struct
 import itertools
-import ignite
 import math
 import timeit
 from . import _six  # noqa:F401
@@ -17,7 +16,9 @@ import sys
 from ..nn import ANIModel, Ensemble, Gaussian
 from ..utils import EnergyShifter, ChemicalSymbolsToInts
 from ..aev import AEVComputer
-from ..ignite import Container, MSELoss, TransformedLoss, RMSEMetric, MAEMetric
+from ..optim import AdamW
+import warnings
+import textwrap
 
 
 class Constants(collections.abc.Mapping):
@@ -380,8 +381,6 @@ def hartree2kcal(x):
 
 
 if sys.version_info[0] > 2:
-    from ..data import BatchedANIDataset  # noqa: E402
-    from ..data import AEVCacheLoader  # noqa: E402
 
     class Trainer:
         """Train with NeuroChem training configurations.
@@ -391,7 +390,7 @@ if sys.version_info[0] > 2:
             device (:class:`torch.device`): device to train the model
             tqdm (bool): whether to enable tqdm
             tensorboard (str): Directory to store tensorboard log file, set to
-                ``None`` to disable tensorboardX.
+                ``None`` to disable tensorboard.
             aev_caching (bool): Whether to use AEV caching.
             checkpoint_name (str): Name of the checkpoint file, checkpoints
                 will be stored in the network directory with this file name.
@@ -400,18 +399,46 @@ if sys.version_info[0] > 2:
         def __init__(self, filename, device=torch.device('cuda'), tqdm=False,
                      tensorboard=None, aev_caching=False,
                      checkpoint_name='model.pt'):
+            try:
+                import ignite
+                from ..ignite import Container, MSELoss, TransformedLoss, RMSEMetric, MAEMetric, MaxAEMetric
+                from ..data import BatchedANIDataset  # noqa: E402
+                from ..data import AEVCacheLoader  # noqa: E402
+            except ImportError:
+                raise RuntimeError(
+                    'NeuroChem Trainer requires ignite,'
+                    'please install pytorch-ignite-nightly from PYPI')
+
+            self.ignite = ignite
+
+            class dummy:
+                pass
+
+            self.imports = dummy()
+            self.imports.Container = Container
+            self.imports.MSELoss = MSELoss
+            self.imports.TransformedLoss = TransformedLoss
+            self.imports.RMSEMetric = RMSEMetric
+            self.imports.MaxAEMetric = MaxAEMetric
+            self.imports.MAEMetric = MAEMetric
+            self.imports.BatchedANIDataset = BatchedANIDataset
+            self.imports.AEVCacheLoader = AEVCacheLoader
+
+            self.warned = False
+
             self.filename = filename
             self.device = device
             self.aev_caching = aev_caching
             self.checkpoint_name = checkpoint_name
+            self.parameters = []
             if tqdm:
                 import tqdm
                 self.tqdm = tqdm.tqdm
             else:
                 self.tqdm = None
             if tensorboard is not None:
-                import tensorboardX
-                self.tensorboard = tensorboardX.SummaryWriter(
+                import torch.utils.tensorboard
+                self.tensorboard = torch.utils.tensorboard.SummaryWriter(
                     log_dir=tensorboard)
                 self.training_eval_every = 20
             else:
@@ -591,7 +618,6 @@ if sys.version_info[0] > 2:
             input_size, network_setup = network_setup
             if input_size != self.aev_computer.aev_length:
                 raise ValueError('AEV size and input size does not match')
-            l2reg = []
             atomic_nets = {}
             for atom_type in network_setup:
                 layers = network_setup[atom_type]
@@ -610,19 +636,31 @@ if sys.version_info[0] > 2:
                         modules.append(activation)
                     del layer['activation']
                     if 'l2norm' in layer:
+                        if not self.warned:
+                            warnings.warn(textwrap.dedent("""
+                                Currently TorchANI training with weight decay can not reproduce the training
+                                result of NeuroChem with the same training setup. If you really want to use
+                                weight decay, consider smaller rates and and make sure you do enough validation
+                                to check if you get expected result."""))
+                            self.warned = True
                         if layer['l2norm'] == 1:
-                            # NB: The "L2" implemented in NeuroChem is actually
-                            # not L2 but weight decay. The difference of these
-                            # two is:
-                            # https://arxiv.org/pdf/1711.05101.pdf
-                            # There is a pull request on github/pytorch
-                            # implementing AdamW, etc.:
-                            # https://github.com/pytorch/pytorch/pull/4429
-                            # There is no plan to support the "L2" settings in
-                            # input file before AdamW get merged into pytorch.
-                            raise NotImplementedError('L2 not supported yet')
+                            self.parameters.append({
+                                'params': [module.weight],
+                                'weight_decay': layer['l2valu'],
+                            })
+                            self.parameters.append({
+                                'params': [module.bias],
+                            })
+                        else:
+                            self.parameters.append({
+                                'params': module.parameters(),
+                            })
                         del layer['l2norm']
                         del layer['l2valu']
+                    else:
+                        self.parameters.append({
+                            'params': module.parameters(),
+                        })
                     if layer:
                         raise ValueError(
                             'unrecognized parameter in layer setup')
@@ -634,16 +672,13 @@ if sys.version_info[0] > 2:
                 self.nnp = self.model
             else:
                 self.nnp = torch.nn.Sequential(self.aev_computer, self.model)
-            self.container = Container({'energies': self.nnp}).to(self.device)
+            self.container = self.imports.Container({'energies': self.nnp}).to(self.device)
 
             # losses
-            def l2():
-                return sum([c * (m.weight ** 2).sum() for c, m in l2reg])
-            self.mse_loss = TransformedLoss(MSELoss('energies'),
-                                            lambda x: x + l2())
-            self.exp_loss = TransformedLoss(
-                MSELoss('energies'),
-                lambda x: 0.5 * (torch.exp(2 * x) - 1) + l2())
+            self.mse_loss = self.imports.MSELoss('energies')
+            self.exp_loss = self.imports.TransformedLoss(
+                self.imports.MSELoss('energies'),
+                lambda x: 0.5 * (torch.exp(2 * x) - 1))
 
             if params:
                 raise ValueError('unrecognized parameter')
@@ -653,17 +688,18 @@ if sys.version_info[0] > 2:
             self.best_validation_rmse = math.inf
 
         def evaluate(self, dataset):
-            """Evaluate on given dataset to compute RMSE and MAE."""
-            evaluator = ignite.engine.create_supervised_evaluator(
+            """Evaluate on given dataset to compute RMSE and MaxAE."""
+            evaluator = self.ignite.engine.create_supervised_evaluator(
                 self.container,
                 metrics={
-                    'RMSE': RMSEMetric('energies'),
-                    'MAE': MAEMetric('energies'),
+                    'RMSE': self.imports.RMSEMetric('energies'),
+                    'MAE': self.imports.MAEMetric('energies'),
+                    'MaxAE': self.imports.MaxAEMetric('energies'),
                 }
             )
             evaluator.run(dataset)
             metrics = evaluator.state.metrics
-            return hartree2kcal(metrics['RMSE']), hartree2kcal(metrics['MAE'])
+            return hartree2kcal(metrics['RMSE']), hartree2kcal(metrics['MAE']), hartree2kcal(metrics['MaxAE'])
 
         def load_data(self, training_path, validation_path):
             """Load training and validation dataset from file.
@@ -672,14 +708,14 @@ if sys.version_info[0] > 2:
             directory, otherwise it should be path to the dataset.
             """
             if self.aev_caching:
-                self.training_set = AEVCacheLoader(training_path)
-                self.validation_set = AEVCacheLoader(validation_path)
+                self.training_set = self.imports.AEVCacheLoader(training_path)
+                self.validation_set = self.imports.AEVCacheLoader(validation_path)
             else:
-                self.training_set = BatchedANIDataset(
+                self.training_set = self.imports.BatchedANIDataset(
                     training_path, self.consts.species_to_tensor,
                     self.training_batch_size, device=self.device,
                     transform=[self.shift_energy.subtract_from_dataset])
-                self.validation_set = BatchedANIDataset(
+                self.validation_set = self.imports.BatchedANIDataset(
                     validation_path, self.consts.species_to_tensor,
                     self.validation_batch_size, device=self.device,
                     transform=[self.shift_energy.subtract_from_dataset])
@@ -690,40 +726,40 @@ if sys.version_info[0] > 2:
 
             def decorate(trainer):
 
-                @trainer.on(ignite.engine.Events.STARTED)
+                @trainer.on(self.ignite.engine.Events.STARTED)
                 def initialize(trainer):
                     trainer.state.no_improve_count = 0
                     trainer.state.epoch += self.global_epoch
                     trainer.state.iteration += self.global_iteration
 
-                @trainer.on(ignite.engine.Events.COMPLETED)
+                @trainer.on(self.ignite.engine.Events.COMPLETED)
                 def finalize(trainer):
                     self.global_epoch = trainer.state.epoch
                     self.global_iteration = trainer.state.iteration
 
                 if self.nmax > 0:
-                    @trainer.on(ignite.engine.Events.EPOCH_COMPLETED)
+                    @trainer.on(self.ignite.engine.Events.EPOCH_COMPLETED)
                     def terminate_when_nmax_reaches(trainer):
                         if trainer.state.epoch >= self.nmax:
                             trainer.terminate()
 
                 if self.tqdm is not None:
-                    @trainer.on(ignite.engine.Events.EPOCH_STARTED)
+                    @trainer.on(self.ignite.engine.Events.EPOCH_STARTED)
                     def init_tqdm(trainer):
                         trainer.state.tqdm = self.tqdm(
                             total=len(self.training_set), desc='epoch')
 
-                    @trainer.on(ignite.engine.Events.ITERATION_COMPLETED)
+                    @trainer.on(self.ignite.engine.Events.ITERATION_COMPLETED)
                     def update_tqdm(trainer):
                         trainer.state.tqdm.update(1)
 
-                    @trainer.on(ignite.engine.Events.EPOCH_COMPLETED)
+                    @trainer.on(self.ignite.engine.Events.EPOCH_COMPLETED)
                     def finalize_tqdm(trainer):
                         trainer.state.tqdm.close()
 
-                @trainer.on(ignite.engine.Events.EPOCH_STARTED)
+                @trainer.on(self.ignite.engine.Events.EPOCH_STARTED)
                 def validation_and_checkpoint(trainer):
-                    trainer.state.rmse, trainer.state.mae = \
+                    trainer.state.rmse, trainer.state.mae, trainer.state.maxae = \
                         self.evaluate(self.validation_set)
                     if trainer.state.rmse < self.best_validation_rmse:
                         trainer.state.no_improve_count = 0
@@ -737,7 +773,7 @@ if sys.version_info[0] > 2:
                         trainer.terminate()
 
                 if self.tensorboard is not None:
-                    @trainer.on(ignite.engine.Events.EPOCH_STARTED)
+                    @trainer.on(self.ignite.engine.Events.EPOCH_STARTED)
                     def log_per_epoch(trainer):
                         elapsed = round(timeit.default_timer() - start, 2)
                         epoch = trainer.state.epoch
@@ -749,6 +785,8 @@ if sys.version_info[0] > 2:
                                                     trainer.state.rmse, epoch)
                         self.tensorboard.add_scalar('validation_mae_vs_epoch',
                                                     trainer.state.mae, epoch)
+                        self.tensorboard.add_scalar('validation_maxae_vs_epoch',
+                                                    trainer.state.maxae, epoch)
                         self.tensorboard.add_scalar(
                             'best_validation_rmse_vs_epoch',
                             self.best_validation_rmse, epoch)
@@ -756,16 +794,18 @@ if sys.version_info[0] > 2:
                             'no_improve_count_vs_epoch',
                             trainer.state.no_improve_count, epoch)
 
-                        # compute training RMSE and MAE
+                        # compute training RMSE, MAE and MaxAE
                         if epoch % self.training_eval_every == 1:
-                            training_rmse, training_mae = \
+                            training_rmse, training_mae, training_maxae = \
                                 self.evaluate(self.training_set)
                             self.tensorboard.add_scalar(
                                 'training_rmse_vs_epoch', training_rmse, epoch)
                             self.tensorboard.add_scalar(
                                 'training_mae_vs_epoch', training_mae, epoch)
+                            self.tensorboard.add_scalar(
+                                'training_mae_vs_epoch', training_maxae, epoch)
 
-                    @trainer.on(ignite.engine.Events.ITERATION_COMPLETED)
+                    @trainer.on(self.ignite.engine.Events.ITERATION_COMPLETED)
                     def log_loss(trainer):
                         iteration = trainer.state.iteration
                         loss = trainer.state.output
@@ -776,21 +816,21 @@ if sys.version_info[0] > 2:
 
             # training using mse loss first until the validation MAE decrease
             # to < 1 Hartree
-            optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
-            trainer = ignite.engine.create_supervised_trainer(
+            optimizer = AdamW(self.parameters, lr=lr)
+            trainer = self.ignite.engine.create_supervised_trainer(
                 self.container, optimizer, self.mse_loss)
             decorate(trainer)
 
-            @trainer.on(ignite.engine.Events.EPOCH_STARTED)
+            @trainer.on(self.ignite.engine.Events.EPOCH_STARTED)
             def terminate_if_smaller_enough(trainer):
-                if trainer.state.mae < 1.0:
+                if trainer.state.rmse < 10.0:
                     trainer.terminate()
 
             trainer.run(self.training_set, max_epochs=math.inf)
 
             while lr > self.min_lr:
-                optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
-                trainer = ignite.engine.create_supervised_trainer(
+                optimizer = AdamW(self.parameters, lr=lr)
+                trainer = self.ignite.engine.create_supervised_trainer(
                     self.container, optimizer, self.exp_loss)
                 decorate(trainer)
                 trainer.run(self.training_set, max_epochs=math.inf)

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani/optim.py

@@ -0,0 +1,113 @@
+"""AdamW implementation"""
+import math
+import torch
+from torch.optim.optimizer import Optimizer
+
+
+# Copied and modified from: https://github.com/pytorch/pytorch/pull/4429
+class AdamW(Optimizer):
+    r"""Implements AdamW algorithm.
+
+    It has been proposed in `Decoupled Weight Decay Regularization`_.
+
+    Arguments:
+        params (iterable): iterable of parameters to optimize or dicts defining
+            parameter groups
+        lr (float, optional): learning rate (default: 1e-3)
+        betas (Tuple[float, float], optional): coefficients used for computing
+            running averages of gradient and its square (default: (0.9, 0.999))
+        eps (float, optional): term added to the denominator to improve
+            numerical stability (default: 1e-8)
+        weight_decay (float, optional): weight decay factor (default: 0)
+        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
+            algorithm from the paper `On the Convergence of Adam and Beyond`_
+            (default: False)
+
+    .. _Adam\: A Method for Stochastic Optimization:
+        https://arxiv.org/abs/1412.6980
+    .. _Decoupled Weight Decay Regularization:
+        https://arxiv.org/abs/1711.05101
+    .. _On the Convergence of Adam and Beyond:
+        https://openreview.net/forum?id=ryQu7f-RZ
+    """
+
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
+                 weight_decay=0, amsgrad=False):
+        if not 0.0 <= lr:
+            raise ValueError("Invalid learning rate: {}".format(lr))
+        if not 0.0 <= eps:
+            raise ValueError("Invalid epsilon value: {}".format(eps))
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
+        defaults = dict(lr=lr, betas=betas, eps=eps,
+                        weight_decay=weight_decay, amsgrad=amsgrad)
+        super(AdamW, self).__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super(AdamW, self).__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('amsgrad', False)
+
+    def step(self, closure=None):
+        """Performs a single optimization step.
+
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        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('Adam does not support sparse gradients, please consider SparseAdam instead')
+                amsgrad = group['amsgrad']
+
+                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)
+                    if amsgrad:
+                        # Maintains max of all exp. moving avg. of sq. grad. values
+                        state['max_exp_avg_sq'] = torch.zeros_like(p.data)
+
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+                if amsgrad:
+                    max_exp_avg_sq = state['max_exp_avg_sq']
+                beta1, beta2 = group['betas']
+
+                state['step'] += 1
+
+                # Decay the first and second moment running average coefficient
+                exp_avg.mul_(beta1).add_(1 - beta1, grad)
+                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
+                if amsgrad:
+                    # Maintains the maximum of all 2nd moment running avg. till now
+                    torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)
+                    # Use the max. for normalizing running avg. of gradient
+                    denom = max_exp_avg_sq.sqrt().add_(group['eps'])
+                else:
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+
+                bias_correction1 = 1 - beta1 ** state['step']
+                bias_correction2 = 1 - beta2 ** state['step']
+                step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1
+
+                p.data.addcdiv_(-step_size, exp_avg, denom)
+
+                if group['weight_decay'] != 0:
+                    p.data.add_(-group['weight_decay'], p.data)
+
+        return loss

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani/utils.py

@@ -1,4 +1,5 @@
 import torch
+import torch.utils.data
 import math
 
 
@@ -247,18 +248,19 @@ def vibrational_analysis(masses, hessian, unit='cm^-1'):
     # We solve this eigenvalue problem through Lowdin diagnolization:
     # Hq = w^2 * Tq ==> Hq = w^2 * T^(1/2) T^(1/2) q
     # Letting q' = T^(1/2) q, we then have
-    # T^(-1/2) H T^(1/2) q' = w^2 * q'
+    # T^(-1/2) H T^(-1/2) q' = w^2 * q'
     inv_sqrt_mass = (1 / masses.sqrt()).repeat_interleave(3, dim=1)  # shape (molecule, 3 * atoms)
     mass_scaled_hessian = hessian * inv_sqrt_mass.unsqueeze(1) * inv_sqrt_mass.unsqueeze(2)
     if mass_scaled_hessian.shape[0] != 1:
         raise ValueError('The input should contain only one molecule')
     mass_scaled_hessian = mass_scaled_hessian.squeeze(0)
-    eigenvalues = torch.symeig(mass_scaled_hessian).eigenvalues
+    eigenvalues, eigenvectors = torch.symeig(mass_scaled_hessian, eigenvectors=True)
     angular_frequencies = eigenvalues.sqrt()
     frequencies = angular_frequencies / (2 * math.pi)
     # converting from sqrt(hartree / (amu * angstrom^2)) to cm^-1
     wavenumbers = frequencies * 17092
-    return wavenumbers
+    modes = (eigenvectors.t() * inv_sqrt_mass).reshape(frequencies.numel(), -1, 3)
+    return wavenumbers, modes
 
 
 __all__ = ['pad', 'pad_coordinates', 'present_species', 'hessian',

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/{torchani-0.6-py3.7.egg-info → torchani-0.7-py3.7.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: torchani
-Version: 0.6
+Version: 0.7
 Summary: PyTorch implementation of ANI
 Home-page: https://github.com/zasdfgbnm/torchani
 Author: Xiang Gao

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/{torchani-0.6-py3.7.egg-info → torchani-0.7-py3.7.egg-info}/SOURCES.txt

@@ -42,6 +42,7 @@ examples/energy_force.py
 examples/load_from_neurochem.py
 examples/neurochem_trainer.py
 examples/nnp_training.py
+examples/nnp_training_ignite.py
 examples/vibration_analysis.py
 tests/test_aev.py
 tests/test_ase.py
@@ -159,104 +160,14 @@ tests/test_data/NIST/all
 tests/test_data/NeuroChemOptimized/all
 tests/test_data/benzene-md/0.dat
 tests/test_data/benzene-md/1.dat
-tests/test_data/benzene-md/10.dat
-tests/test_data/benzene-md/11.dat
-tests/test_data/benzene-md/12.dat
-tests/test_data/benzene-md/13.dat
-tests/test_data/benzene-md/14.dat
-tests/test_data/benzene-md/15.dat
-tests/test_data/benzene-md/16.dat
-tests/test_data/benzene-md/17.dat
-tests/test_data/benzene-md/18.dat
-tests/test_data/benzene-md/19.dat
 tests/test_data/benzene-md/2.dat
-tests/test_data/benzene-md/20.dat
-tests/test_data/benzene-md/21.dat
-tests/test_data/benzene-md/22.dat
-tests/test_data/benzene-md/23.dat
-tests/test_data/benzene-md/24.dat
-tests/test_data/benzene-md/25.dat
-tests/test_data/benzene-md/26.dat
-tests/test_data/benzene-md/27.dat
-tests/test_data/benzene-md/28.dat
-tests/test_data/benzene-md/29.dat
 tests/test_data/benzene-md/3.dat
-tests/test_data/benzene-md/30.dat
-tests/test_data/benzene-md/31.dat
-tests/test_data/benzene-md/32.dat
-tests/test_data/benzene-md/33.dat
-tests/test_data/benzene-md/34.dat
-tests/test_data/benzene-md/35.dat
-tests/test_data/benzene-md/36.dat
-tests/test_data/benzene-md/37.dat
-tests/test_data/benzene-md/38.dat
-tests/test_data/benzene-md/39.dat
 tests/test_data/benzene-md/4.dat
-tests/test_data/benzene-md/40.dat
-tests/test_data/benzene-md/41.dat
-tests/test_data/benzene-md/42.dat
-tests/test_data/benzene-md/43.dat
-tests/test_data/benzene-md/44.dat
-tests/test_data/benzene-md/45.dat
-tests/test_data/benzene-md/46.dat
-tests/test_data/benzene-md/47.dat
-tests/test_data/benzene-md/48.dat
-tests/test_data/benzene-md/49.dat
 tests/test_data/benzene-md/5.dat
-tests/test_data/benzene-md/50.dat
-tests/test_data/benzene-md/51.dat
-tests/test_data/benzene-md/52.dat
-tests/test_data/benzene-md/53.dat
-tests/test_data/benzene-md/54.dat
-tests/test_data/benzene-md/55.dat
-tests/test_data/benzene-md/56.dat
-tests/test_data/benzene-md/57.dat
-tests/test_data/benzene-md/58.dat
-tests/test_data/benzene-md/59.dat
 tests/test_data/benzene-md/6.dat
-tests/test_data/benzene-md/60.dat
-tests/test_data/benzene-md/61.dat
-tests/test_data/benzene-md/62.dat
-tests/test_data/benzene-md/63.dat
-tests/test_data/benzene-md/64.dat
-tests/test_data/benzene-md/65.dat
-tests/test_data/benzene-md/66.dat
-tests/test_data/benzene-md/67.dat
-tests/test_data/benzene-md/68.dat
-tests/test_data/benzene-md/69.dat
 tests/test_data/benzene-md/7.dat
-tests/test_data/benzene-md/70.dat
-tests/test_data/benzene-md/71.dat
-tests/test_data/benzene-md/72.dat
-tests/test_data/benzene-md/73.dat
-tests/test_data/benzene-md/74.dat
-tests/test_data/benzene-md/75.dat
-tests/test_data/benzene-md/76.dat
-tests/test_data/benzene-md/77.dat
-tests/test_data/benzene-md/78.dat
-tests/test_data/benzene-md/79.dat
 tests/test_data/benzene-md/8.dat
-tests/test_data/benzene-md/80.dat
-tests/test_data/benzene-md/81.dat
-tests/test_data/benzene-md/82.dat
-tests/test_data/benzene-md/83.dat
-tests/test_data/benzene-md/84.dat
-tests/test_data/benzene-md/85.dat
-tests/test_data/benzene-md/86.dat
-tests/test_data/benzene-md/87.dat
-tests/test_data/benzene-md/88.dat
-tests/test_data/benzene-md/89.dat
 tests/test_data/benzene-md/9.dat
-tests/test_data/benzene-md/90.dat
-tests/test_data/benzene-md/91.dat
-tests/test_data/benzene-md/92.dat
-tests/test_data/benzene-md/93.dat
-tests/test_data/benzene-md/94.dat
-tests/test_data/benzene-md/95.dat
-tests/test_data/benzene-md/96.dat
-tests/test_data/benzene-md/97.dat
-tests/test_data/benzene-md/98.dat
-tests/test_data/benzene-md/99.dat
 tests/test_data/tripeptide-md/0.dat
 tests/test_data/tripeptide-md/1.dat
 tests/test_data/tripeptide-md/10.dat
@@ -2193,6 +2104,7 @@ tools/generate-unit-test-expect/nist-dataset/README.md
 tools/generate-unit-test-expect/nist-dataset/nist.py
 tools/generate-unit-test-expect/nist-dataset/result.json
 tools/generate-unit-test-expect/others/Benzene.cif
+tools/generate-unit-test-expect/others/Benzene.pdb
 tools/generate-unit-test-expect/tripeptide/tripeptide-000.ipt_optimization.xyz
 tools/generate-unit-test-expect/tripeptide/tripeptide-001.ipt_optimization.xyz
 tools/generate-unit-test-expect/tripeptide/tripeptide-002.ipt_optimization.xyz
@@ -2444,6 +2356,7 @@ torchani/ase.py
 torchani/ignite.py
 torchani/models.py
 torchani/nn.py
+torchani/optim.py
 torchani/utils.py
 torchani.egg-info/PKG-INFO
 torchani.egg-info/SOURCES.txt

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani-0.7-py3.7.egg-info/requires.txt

@@ -0,0 +1,2 @@
+torch-nightly
+lark-parser

opt/hostedtoolcache/Python/3.7.2/x64/lib/python3.7/site-packages/torchani-0.6-py3.7.egg-info/requires.txt

@@ -1,4 +0,0 @@
-torch-nightly
-pytorch-ignite-nightly
-lark-parser
-h5py