agox 2.2.2__tar.gz → 3.7.0__tar.gz

agox-3.7.0/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include agox/test *
+include agox/models/datasets/*.traj
+global-include *.pyx
+

agox-3.7.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: agox
+Version: 3.7.0
+Summary: Atomistic Global Optimziation X is a framework for structure optimization in materials science.
+Author: AGOX Developers
+Author-email: "Mads-Peter V. Christiansen" <machri@phys.au.dk>, Nikolaj Rønne <nronne@phys.au.dk>, Bjørk Hammer <hammer@phys.au.dk>
+License: GNU General Public License v3.0 or later
+Project-URL: homepage, https://agox.gitlab.io/agox/
+Project-URL: Repository, https://gitlab.com/agox/agox
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy<=1.26.4
+Requires-Dist: ase
+Requires-Dist: matplotlib
+Requires-Dist: cymem
+Requires-Dist: scikit-learn
+Requires-Dist: h5py
+Requires-Dist: matscipy
+Requires-Dist: importlib-resources>1.3; python_version < "3.9"
+Requires-Dist: dscribe>=2.0.0
+Requires-Dist: nbformat
+Requires-Dist: typing_extensions
+Requires-Dist: ray
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinx-autoapi; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: sphinx-tabs; extra == "docs"
+Provides-Extra: all
+Requires-Dist: agox[docs,test]; extra == "all"
+
+# Atomistic Global Optimization X (AGOX)
+
+AGOX is a package for global optimization of atomic system using e.g. the energy 
+calculated from density functional theory as the objective function. AGOX interfaces 
+with the Atomistic Simulation Environment (ASE) and as such supports any of 
+calculators in ASE as objectives for optimization. 
+
+AGOX is built to be flexible, consisting of modules that can be put together to 
+create an optimization algorithm, from simple random searches to Bayesian searches 
+guided by a surrogate model and many more. 
+
+Check out the documentation at 
+
+https://agox.gitlab.io/agox/
+
+# Contributions & Issues 
+
+Feel free to make a fork and submit a merge request! 
+
+If you have an issue or a question please post it on the issue board! 
+
+# Authors 
+
+The main AGOX framework has been written by 
+* Mads-Peter Verner Christiansen
+* Nikolaj Rønne
+* Bjørk Hammer
+
+with inspiration and help from current and previous members of the Hammer group at Aarhus University, Denmark.
+Parts of the code have been contributed by
+
+* Andreas Slavensky (Complementary Energy Generator)
+
+# License
+
+AGOX is released under the GPLv3 license. 
+
+

agox-3.7.0/README.md

@@ -0,0 +1,38 @@
+# Atomistic Global Optimization X (AGOX)
+
+AGOX is a package for global optimization of atomic system using e.g. the energy 
+calculated from density functional theory as the objective function. AGOX interfaces 
+with the Atomistic Simulation Environment (ASE) and as such supports any of 
+calculators in ASE as objectives for optimization. 
+
+AGOX is built to be flexible, consisting of modules that can be put together to 
+create an optimization algorithm, from simple random searches to Bayesian searches 
+guided by a surrogate model and many more. 
+
+Check out the documentation at 
+
+https://agox.gitlab.io/agox/
+
+# Contributions & Issues 
+
+Feel free to make a fork and submit a merge request! 
+
+If you have an issue or a question please post it on the issue board! 
+
+# Authors 
+
+The main AGOX framework has been written by 
+* Mads-Peter Verner Christiansen
+* Nikolaj Rønne
+* Bjørk Hammer
+
+with inspiration and help from current and previous members of the Hammer group at Aarhus University, Denmark.
+Parts of the code have been contributed by
+
+* Andreas Slavensky (Complementary Energy Generator)
+
+# License
+
+AGOX is released under the GPLv3 license. 
+
+

agox-3.7.0/agox/__init__.py

@@ -0,0 +1,25 @@
+import os
+
+# Versioning
+__version_info__ = (3, 7, 0)
+__version__ = '{}.{}.{}'.format(*__version_info__)
+
+# Extra versioning - Mainly for managing Pypi releases.
+version_extra = os.environ.get('AGOX_VERSION_EXTRA', None)
+if version_extra:
+    __version__ = '{}{}'.format(__version__, version_extra)
+
+try: # When installing the package we don't need to actually import.
+    from agox.module import Module
+    from agox.observer import Observer
+    from agox.writer import Writer
+    from agox.tracker import Tracker
+    from agox.main import AGOX
+
+    __all__ = ['Module', 'Observer', 'Writer', 'Tracker', 'AGOX', '__version__']
+
+except ImportError:
+    pass
+
+
+

{agox-2.2.2 → agox-3.7.0}/agox/acquisitors/ABC_acquisitor.py

@@ -3,49 +3,59 @@ import numpy as np
 from agox.observer import Observer
 from agox.writer import Writer, agox_writer
 
+
 class AcquisitorBaseClass(ABC, Observer, Writer):
 
     """
-    Acquisition Base Class. 
-
-    See: Observer-class for information on gets, sets, order. 
-
-    verbose: bool
-        Controls how much printing the module does. 
-
-    Abstract methods:
-
-    calculate_acquisition_function: 
-        Calculates acquisition function for given candidates.         
+    Base-class for acquisitors.
+
+    Parameters
+    -----------
+    verbose : bool
+        Controls how much printing the module does.
+    order : int
+        Order of the observer.
+    gets : dict
+        Dictionary of gets, passed to the agox.observer.Observer.
+    sets : dict
+        Dictionary of sets, passed to the agox.observer.Observer.
     """
 
-    def __init__(self, order=4, gets={'get_key':'candidates'}, sets={'set_key':'prioritized_candidates'}, verbose=True, 
-                use_counter=True, prefix='', surname=''):
+    def __init__(
+        self,
+        order=4,
+        gets={"get_key": "candidates"},
+        sets={"set_key": "prioritized_candidates"},
+        verbose=True,
+        use_counter=True,
+        prefix="",
+        surname="",
+    ):
         Observer.__init__(self, gets=gets, sets=sets, order=order, surname=surname)
         Writer.__init__(self, verbose=verbose, use_counter=use_counter, prefix=prefix)
 
-        self.add_observer_method(self.prioritize_candidates,
-                                 sets=self.sets[0], gets=self.gets[0], order=self.order[0],
-                                 handler_identifier='AGOX')
-
-    ########################################################################################
-    # Required methods
-    ########################################################################################
+        self.add_observer_method(
+            self.prioritize_candidates,
+            sets=self.sets[0],
+            gets=self.gets[0],
+            order=self.order[0],
+            handler_identifier="AGOX",
+        )
 
     @abstractmethod
     def calculate_acquisition_function(self, candidates):
         """
-        Implements the acquisition function. 
+        Implements the acquisition function.
 
         Parameters
         -----------
-        candidates: list
-            List of candidates that the acquisition function will be evaluated for. 
-        
+        candidates : list
+            List of candidates that the acquisition function will be evaluated for.
+
         Returns
         --------
         np.array
-            Numpy array of acquisition function values. 
+            Numpy array of acquisition function values.
 
         """
         return acquisition_values
@@ -54,17 +64,22 @@ class AcquisitorBaseClass(ABC, Observer, Writer):
     @Observer.observer_method
     def prioritize_candidates(self, state):
         """
-        Method that is attached to the AGOX iteration loop as an observer - not intended for use outside of that loop. 
+        Method that is attached to the AGOX iteration loop as an observer - not intended for use outside of that loop.
 
-        The method does the following: 
+        The method does the following:
         1. Gets candidates from the cache using 'get_key'.
-        2. Removes 'None' from the candidate list. 
-        3. Calculates and sorts according to acquisition function. 
+        2. Removes 'None' from the candidate list.
+        3. Calculates and sorts according to acquisition function.
         4. Adds the sorted candidates to cache with 'set_key'
-        5. Prints information.         
+        5. Prints information.
+
+        Parameters
+        -----------
+        state: agox.main.State
+            State object that contains the iteration data.
         """
 
-        # Get data from the iteration data dict. 
+        # Get data from the iteration data dict.
         candidate_list = state.get_from_cache(self, self.get_key)
         candidate_list = list(filter(None, candidate_list))
 
@@ -74,100 +89,116 @@ class AcquisitorBaseClass(ABC, Observer, Writer):
         else:
             acquisition_values = np.zeros(len(candidate_list))
         # Add the prioritized candidates to the iteration data in append mode!
-        state.add_to_cache(self, self.set_key, candidate_list, mode='a')
+        state.add_to_cache(self, self.set_key, candidate_list, mode="a")
 
         self.print_information(candidate_list, acquisition_values)
-            
+
     ########################################################################################
     # Default methods
     ########################################################################################
-        
-    def sort_according_to_acquisition_function(self, candidates):        
+
+    def sort_according_to_acquisition_function(self, candidates):
         """
-        Calculates acquisiton-function based on the implemeneted version calculate_acquisition_function. 
+        Calculates acquisiton-function based on the implemeneted version calculate_acquisition_function.
 
-        Note: Sorted so that the candidate with the LOWEST acquisition function value is first. 
+        Note: Sorted so that the candidate with the LOWEST acquisition function value is first.
 
         Parameters
         ------------
         candidates: list
-            List of candidate objects. 
-        
-        Returns: 
+            List of candidate objects.
+
+        Returns:
         -----------
         list
             List of candidates sorted according to increasing acquisition value (lowest first).
         np.array
-            Array of acquisition function values in the same order as the sorted list, i.e. increasing. 
+            Array of acquisition function values in the same order as the sorted list, i.e. increasing.
 
         """
         acquisition_values = self.calculate_acquisition_function(candidates)
         sort_idx = np.argsort(acquisition_values)
         sorted_candidates = [candidates[i] for i in sort_idx]
         acquisition_values = acquisition_values[sort_idx]
-        [candidate.add_meta_information('acquisition_value', acquisition_value) for candidate, acquisition_value in zip(sorted_candidates, acquisition_values)]          
+        [
+            candidate.add_meta_information("acquisition_value", acquisition_value)
+            for candidate, acquisition_value in zip(sorted_candidates, acquisition_values)
+        ]
         return sorted_candidates, acquisition_values
 
     def get_random_candidate(self):
-        DeprecationWarning('Will be removed in the future. Please use collector.get_random_candidate')
+        DeprecationWarning("Will be removed in the future. Please use collector.get_random_candidate")
         return self.collector.get_random_candidate()
 
     def print_information(self, candidates, acquisition_values):
         """
-        Printing function for analysis/debugging/sanity checking. 
+        Printing function for analysis/debugging/sanity checking.
 
         Parameters
         -----------
         candidates: list
-            List of candidate objects. 
+            List of candidate objects.
         acquisition_values: np.array
-            Acquisition function value for each candidate in 'candidates'. 
-
+            Acquisition function value for each candidate in 'candidates'.
         """
 
     def get_acquisition_calculator(self):
         """
-        Creates a calculator for the acquisiton function that can be used for e.g. relaxation. 
+        Creates a calculator for the acquisiton function that can be used for e.g. relaxation.
 
         Returns
         --------
         ASE Calculator
-            ASE calculator where the energy is the acquisition function and forces are the forces of the acquisition forces. 
+            ASE calculator where the energy is the acquisition function and forces are the forces of the acquisition forces.
         """
-
         raise NotImplementedError("'get_acqusition_calculator' is not implemented for this acquisitor")
 
+
 from ase.calculators.calculator import Calculator, all_changes
 from agox.module import Module
 
+
 class AcquisitonCalculatorBaseClass(Calculator, Module):
 
-    name = 'AcqusitionCalculator'
+    name = "AcqusitionCalculator"
+
+    """
+    Base-class for calculators that are used for acquisition functions.
+
+    Parameters
+    -----------
+    model: agox.models.ABC_model.ModelBaseClass 
+        A model that is used for the acquisition function.
+    kwargs: dict
+        Dictionary of keyword arguments passed to the Calculator-class.
+
+    """
+
+    def __init__(self, model, **kwargs):
+        Calculator.__init__(self, **kwargs)
+        Module.__init__(self)
+        self.model = model
 
-    def __init__(self, model_calculator, **kwargs):
-        super().__init__(**kwargs)
-        self.model_calculator = model_calculator
-    
     @property
     def verbose(self):
-        return self.model_calculator.verbose
+        return self.model.verbose
 
     def get_model_parameters(self):
-        parameters = self.model_calculator.get_model_parameters()
+        parameters = self.model.get_model_parameters()
         return parameters
 
     def set_model_parameters(self, parameters):
-        self.model_calculator.set_model_parameters(parameters)
+        self.model.set_model_parameters(parameters)
 
     def set_verbosity(self, verbose):
-        self.model_calculator.set_verbosity(verbose)
+        self.model.set_verbosity(verbose)
 
     def get_iteration_number(self):
-        if hasattr(self, 'get_iteration_counter'):
+        if hasattr(self, "get_iteration_counter"):
             return self.get_iteration_counter()
         else:
             return self.iteration
 
     @property
     def ready_state(self):
-        return self.model_calculator.ready_state
+        return self.model.ready_state

agox-3.7.0/agox/acquisitors/EI.py

@@ -0,0 +1,53 @@
+import numpy as np
+from scipy.stats import norm
+from agox.acquisitors import AcquisitorBaseClass
+from agox.observer import Observer
+from agox.writer import agox_writer
+
+class ExpectedImprovementAcquisitor(AcquisitorBaseClass):
+    
+    name = 'EIAcquisitor'
+    
+    def __init__(self, model, database, xi=0.01, **kwargs):
+        super().__init__(maximize=True, **kwargs)
+        self.model = model
+        self.xi = xi
+        self.lowest_energy = 10E10
+        self.add_observer_method(self.update, sets={}, gets={}, order=0, handler_identifier='database')
+        self.attach(database)
+
+    def calculate_acquisition_function(self, candidates):
+        fitness = np.zeros(len(candidates))
+        for i, candidate in enumerate(candidates):
+            E, sigma = self.model.predict_energy_and_uncertainty(candidate)
+            fitness[i] = self.acquisition_function(E, sigma)
+            candidate.add_meta_information('model_energy', E)
+            candidate.add_meta_information('uncertainty', sigma)
+        return fitness
+    
+    def acquisition_function(self, E, sigma):
+        mu = E
+        mu_opt = self.lowest_energy
+        with np.errstate(divide='warn'):
+            imp = mu_opt - mu - self.xi
+            Z = imp / sigma 
+            ei = imp * norm.cdf(Z) + sigma * norm.pdf(Z)
+        return ei
+    
+    def print_information(self, candidates, acquisition_values):
+        if self.do_check():
+            for i, candidate in enumerate(candidates):
+                fitness = acquisition_values[i]
+                E = candidate.get_meta_information('model_energy')
+                sigma = candidate.get_meta_information('uncertainty')
+                self.writer(f'Candidate {i}: E = {E:8.3f}, s = {sigma:8.3f}, EI = {fitness:8.6f}')
+
+    @agox_writer
+    @Observer.observer_method
+    def update(self, database, state):
+        self.lowest_energy = database.get_best_energy()
+        self.writer('Lowest energy: {}'.format(self.lowest_energy))
+
+    def do_check(self, **kwargs):
+        return self.model.ready_state
+

{agox-2.2.2 → agox-3.7.0}/agox/acquisitors/LCB.py

@@ -4,21 +4,40 @@ from ase.calculators.calculator import all_changes
 
 class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
 
+    """
+    Lower Confidence Bound Acquisitor, using predictions and uncertainties from a model.
+    
+    The acquisition function is given by
+
+    .. math::
+
+        F(x) = E(x) - \kappa \sigma(x)
+
+                
+    Parameters
+    -----------
+
+    model: agox.models.ABC_model.ModelBaseClass
+        Model that is used for the acquisition function.
+    kappa: float
+        Constant that is multiplied with the uncertainty.
+    kwargs: dict
+        Dictionary of keyword arguments passed to the AcquisitorBaseClass.        
+    """
+
     name = 'LCBAcquisitor'
 
-    def __init__(self, model_calculator, kappa=1, **kwargs):
+    def __init__(self, model, kappa=1, **kwargs):
         super().__init__(**kwargs)
         self.kappa = kappa
-        self.model_calculator = model_calculator
+        self.model = model
 
     def calculate_acquisition_function(self, candidates):
         fitness = np.zeros(len(candidates))
         
         # Attach calculator and get model_energy
         for i, candidate in enumerate(candidates):
-            candidate.set_calculator(self.model_calculator)
-            E = candidate.get_potential_energy()
-            sigma = candidate.get_uncertainty()
+            E, sigma = self.model.predict_energy_and_uncertainty(candidate)
             fitness[i] = self.acquisition_function(E, sigma)
 
             # For printing:
@@ -28,15 +47,16 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
         return fitness
 
     def print_information(self, candidates, acquisition_values):
-        if self.model_calculator.ready_state:
+        if self.model.ready_state:
             for i, candidate in enumerate(candidates):
                 fitness = acquisition_values[i]
                 Emodel = candidate.get_meta_information('model_energy')
                 sigma = candidate.get_meta_information('uncertainty')
-                self.writer('Candidate: E={:8.3f}, s={:8.3f}, F={:8.3f}'.format(Emodel, sigma, fitness))
+                generator = candidate.get_meta_information('generator')
+                self.writer('Candidate: E={:8.3f}, s={:8.3f}, F={:8.3f}, {}'.format(Emodel, sigma, fitness, generator))
 
     def get_acquisition_calculator(self):
-        return LowerConfidenceBoundCalculator(self.model_calculator, self.acquisition_function, self.acquisition_force)
+        return LowerConfidenceBoundCalculator(self.model, self.acquisition_function, self.acquisition_force)
 
     def acquisition_function(self, E, sigma):
         return E - self.kappa * sigma
@@ -45,14 +65,14 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
         return F - self.kappa*sigma_force
 
     def do_check(self, **kwargs):
-        return self.model_calculator.ready_state
+        return self.model.ready_state
 
 class LowerConfidenceBoundCalculator(AcquisitonCalculatorBaseClass):
 
     implemented_properties = ['energy', 'forces']
 
-    def __init__(self, model_calculator, acquisition_function, acquisition_force, **kwargs):
-        super().__init__(model_calculator, **kwargs)
+    def __init__(self, model, acquisition_function, acquisition_force, **kwargs):
+        super().__init__(model, **kwargs)
         self.acquisition_function = acquisition_function
         self.acquisition_force = acquisition_force
 
@@ -61,15 +81,20 @@ class LowerConfidenceBoundCalculator(AcquisitonCalculatorBaseClass):
                   system_changes=all_changes):
         super().calculate(atoms, properties, system_changes)
 
-        if 'forces' in properties:
-            E, sigma = self.model_calculator.predict_energy(atoms, return_uncertainty=True)
-            F, sigma_force = self.model_calculator.predict_forces(atoms, return_uncertainty=True, acquisition_function=self.acquisition_function)
-            self.results['forces'] = self.acquisition_force(E, F, sigma, sigma_force)
-        else:
-            E, sigma = self.model_calculator.predict_energy(atoms, return_uncertainty=True)
-            
+        derivatives = 'forces' in properties
+        model_data = self.model.converter(atoms, derivatives=derivatives)
+        
+        E = self.model.predict_energy(atoms, **model_data)
+        sigma = self.model.predict_uncertainty(atoms, **model_data)
         self.results['energy'] = self.acquisition_function(E, sigma)
 
+        if derivatives:
+
+            F = self.model.predict_forces(atoms, **model_data)
+            sigma_force = self.model.predict_uncertainty_forces(atoms, **model_data)
+        
+            self.results['forces'] = self.acquisition_force(E, F, sigma, sigma_force)
+
 
         
 

{agox-2.2.2 → agox-3.7.0}/agox/acquisitors/LCB_power.py

@@ -1,5 +1,5 @@
 import numpy as np
-from agox.acquisitors import LowerConfidenceBoundAcquisitor, LowerConfidenceBoundCalculator
+from agox.acquisitors.LCB import LowerConfidenceBoundAcquisitor
 
 class PowerLowerConfidenceBoundAcquisitor(LowerConfidenceBoundAcquisitor):
 

agox-3.7.0/agox/acquisitors/__init__.py

@@ -0,0 +1,28 @@
+"""
+Acquisitors are used to select the next candidate to evaluate among a number of
+candidates, usually by sorting according to some metric. 
+The concept of acquisitors comes from Bayesian search algorithms. 
+
+A common acquisitor is the Lower Confidence Bound (LCB) acquisitor, which 
+selects according to the expression
+
+.. math::
+    LCB(x) = E(x) - \kappa \sigma(x).
+
+Where E(x) is a prediction of the objective function at x, and :math:`\sigma(x)`
+is the uncertainty of the prediction. :math:`\kappa` is a parameter that 
+controls the trade-off between exploration and exploitation. 
+This lets an algorithm choose which candidates to evaluate, but 
+does require the generation of multiple candidates to choose from.
+"""
+
+from .ABC_acquisitor import AcquisitorBaseClass, AcquisitonCalculatorBaseClass
+from .LCB import LowerConfidenceBoundAcquisitor
+from .LCB_power import PowerLowerConfidenceBoundAcquisitor
+
+__all__ = ['AcquisitorBaseClass', 
+           'LowerConfidenceBoundAcquisitor', 
+           'PowerLowerConfidenceBoundAcquisitor'
+           'AcquisitonCalculatorBaseClass',
+           ]
+