agox 3.1.1__tar.gz → 3.7.0rc1__tar.gz

agox-3.7.0rc1/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: agox
+Version: 3.7.0rc1
+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.0rc1/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-3.1.1 → agox-3.7.0rc1}/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,81 +89,96 @@ 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
-    
+
     @property
     def verbose(self):
         return self.model.verbose
@@ -164,7 +194,7 @@ class AcquisitonCalculatorBaseClass(Calculator, Module):
         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

agox-3.7.0rc1/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-3.1.1 → agox-3.7.0rc1}/agox/acquisitors/LCB.py

@@ -4,6 +4,27 @@ 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, kappa=1, **kwargs):
@@ -31,7 +52,8 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
                 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, self.acquisition_function, self.acquisition_force)
@@ -59,16 +81,20 @@ class LowerConfidenceBoundCalculator(AcquisitonCalculatorBaseClass):
                   system_changes=all_changes):
         super().calculate(atoms, properties, system_changes)
 
-        model_data = self.model.converter(atoms)
+        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)
-        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)
         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-3.1.1 → agox-3.7.0rc1}/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.1.1 → agox-3.7.0rc1}/agox/acquisitors/__init__.py

@@ -16,10 +16,13 @@ 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, LowerConfidenceBoundCalculator
+from .LCB import LowerConfidenceBoundAcquisitor
 from .LCB_power import PowerLowerConfidenceBoundAcquisitor
 
+__all__ = ['AcquisitorBaseClass', 
+           'LowerConfidenceBoundAcquisitor', 
+           'PowerLowerConfidenceBoundAcquisitor'
+           'AcquisitonCalculatorBaseClass',
+           ]
+

{agox-3.1.1 → agox-3.7.0rc1}/agox/candidates/ABC_candidate.py

@@ -11,25 +11,25 @@ from agox.utils.cache import Cache
     
 class CandidateBaseClass(ABC, Atoms, Module):
 
-    def __init__(self, template=None, template_indices=None, use_cache=True, **kwargs):
-        """
-
-        Initialization method of the Candidate.
+    """
+    Base-class for Candidate objects.
+
+    Parameters
+    ------------
+    template: ase.Atoms
+        Atoms object of the template structure. Does not need to be supplied
+        if 'template_indices' are given. 
+    template_indices: np.array
+        Indices of template atoms. 
+    kwargs: 
+        Everything that can be supplied to an ASE atoms object, specifically 
+        cell, positions and numbers of ALL atoms - including template atoms.
+    """
 
-        Parameters
-        ------------
-        template: ASE atoms object. 
-            atoms object of the template structure. Does not need to be supplied 
-            if 'template_indices' are given. 
-        template_indices: np.array
-            Indices of template atoms. 
-        kwargs: 
-            Everything that can be supplied to an ASE atoms object, specifically 
-            cell, positions and numbers of ALL atoms - including template atoms. 
-        """
+    def __init__(self, template=None, template_indices=None, use_cache=True, **kwargs):
         Atoms.__init__(self, **kwargs) # This means all Atoms-related stuff gets set. 
         Module.__init__(self, use_cache=use_cache)
-        self.meta_information = dict()
+        self.meta_information = self.info
         
         self.use_cache = use_cache
         self._cache = Cache()
@@ -116,6 +116,48 @@ class CandidateBaseClass(ABC, Atoms, Module):
         """
         self.meta_information[name] = value
 
+    def add_write_key(self,value):
+        """
+        Adds a write key to the candidates meta information.
+
+        Parameters
+        -----------
+        value: str
+            key to add to the write information
+
+        """
+
+        try:
+            keys=self.get_meta_information("write_keys")
+            if isinstance(keys, str):
+                keys=list(keys.split(" "))
+            if value not in keys: 
+                keys.append(value)
+        except: 
+            keys=[value]
+        self.add_meta_information("write_keys",keys)
+
+    
+    def print_properties(self,writer,iteration):
+        keys=self.get_meta_information("write_keys")
+        strings_list=[]
+        write_string="Energy: "+str(iteration)+"  "+str(self.get_potential_energy())+"  "
+        
+        if keys is not None:
+            for key in keys:
+                addendum="["+key+":"+" "+self.get_meta_information(key)+"] "
+                if len(write_string)+len(addendum) > 120:  
+                    strings_list.append(write_string)
+                    write_string = ""
+                
+                write_string+=addendum
+                #self.writer('Energy {:06d}: {}'.format(self.get_iteration_counter(), candidate.get_potential_energy()), flush=True)
+        strings_list.append(write_string)
+        if strings_list is not None:
+            for string in strings_list:
+                writer(string,flush=True)
+
+
     def get_meta_information(self, name):
         """
         Get from the meta_information dict. 
@@ -185,7 +227,13 @@ class CandidateBaseClass(ABC, Atoms, Module):
         """
         return self.meta_information.pop(name, None)
 
-    def get_template(self):
+    def reset_meta_information(self):
+        """
+        Resets meta_information
+        """
+        self.meta_information = dict()
+
+    def get_template(self) -> Atoms:
         """
         Get the template atoms object. 
 
@@ -231,22 +279,6 @@ class CandidateBaseClass(ABC, Atoms, Module):
                 calc = SinglePointCalculator(atoms, energy=self.calc.results['energy'])
             atoms.set_calculator(calc)
 
-    def get_uncertainty(self):
-        """
-        Equivalent of 'atoms.get_potential_energy' but for uncertainty. 
-
-        Returns: 
-        ---------
-        float
-            The uncertainty, returns 0 if 'uncertainty' is not in 
-            'implemeneted_properties' of the model calculator. 
-        """
-        if 'uncertainty' in self.calc.implemented_properties:
-            return self.calc.get_property('uncertainty')
-        else:
-            #print('Calculator {} does not implement uncertainty - Default return: 0')
-            return 0.
-
     def set_postprocess_immunity(self, state):
         """
         Set postprocess immunity. 
@@ -295,7 +327,7 @@ class CandidateBaseClass(ABC, Atoms, Module):
         """
         return self.template_indices
 
-    def get_optimize_indices(self):
+    def get_optimize_indices(self) -> np.array:
         """
         Returns
         --------
@@ -304,7 +336,7 @@ class CandidateBaseClass(ABC, Atoms, Module):
         """
         return np.arange(len(self.template), len(self))
 
-    def get_center_of_geometry(self, all_atoms=False):
+    def get_center_of_geometry(self, all_atoms=False) -> np.array:
         """
         Returns the center of geometry.
 
@@ -342,7 +374,3 @@ def switch_cache(candidate, state):
         prev_state = candidate.use_cache
         candidate.use_cache = state
     return prev_state
-
-
-
-

{agox-3.1.1 → agox-3.7.0rc1}/agox/candidates/__init__.py

@@ -2,7 +2,11 @@
 A candidate is the basic piece of data being moved around in the algorithm. 
 Generators create candidates, and evaluators evaluate the objective function 
 at the coordinates described by the candidate. 
+
+AA
 """
 
-from .ABC_candidate import CandidateBaseClass
-from .standard import StandardCandidate
+from agox.candidates.ABC_candidate import CandidateBaseClass
+from agox.candidates.standard import StandardCandidate
+
+__all__ = ['CandidateBaseClass', 'StandardCandidate']

{agox-3.1.1 → agox-3.7.0rc1}/agox/candidates/standard.py

@@ -2,9 +2,11 @@ from agox.candidates.ABC_candidate import CandidateBaseClass
 from ase.calculators.singlepoint import SinglePointCalculator as SPC
 
 class StandardCandidate(CandidateBaseClass):
+
     """
-    I only really made this to keep the style, but I actually think the fairly simple base-class handles everything.
+    Standard candidate class.
     """
+
     @classmethod
     def from_atoms(cls, template, atoms):
         candidate =  cls(template=template, positions=atoms.positions, numbers=atoms.numbers, cell=atoms.cell, pbc=atoms.pbc)