From df8e2bda01acb686a42d745bd3ef49557dde09db Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Fri, 20 May 2022 15:58:06 +0200 Subject: [PATCH 1/8] WIP: first draft of Pacemaker2022 --- pyiron_contrib/__init__.py | 2 +- .../atomistics/pacemaker/__init__.py | 0 pyiron_contrib/atomistics/pacemaker/job.py | 259 ++++++++++++++++++ 3 files changed, 260 insertions(+), 1 deletion(-) create mode 100644 pyiron_contrib/atomistics/pacemaker/__init__.py create mode 100644 pyiron_contrib/atomistics/pacemaker/job.py diff --git a/pyiron_contrib/__init__.py b/pyiron_contrib/__init__.py index 11cb57a31..71715401f 100644 --- a/pyiron_contrib/__init__.py +++ b/pyiron_contrib/__init__.py @@ -44,7 +44,7 @@ JOB_CLASS_DICT['Atomicrex'] = 'pyiron_contrib.atomistics.atomicrex.atomicrex_job' JOB_CLASS_DICT['StructureMasterInt'] = 'pyiron_contrib.atomistics.atomistics.job.structurelistmasterinteractive' JOB_CLASS_DICT['StorageJob'] = 'pyiron_contrib.RDM.storagejob' - +JOB_CLASS_DICT['Pacemaker2022'] = 'pyiron_contrib.atomistics.pacemaker.job' from ._version import get_versions diff --git a/pyiron_contrib/atomistics/pacemaker/__init__.py b/pyiron_contrib/atomistics/pacemaker/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py new file mode 100644 index 000000000..93302c0f2 --- /dev/null +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -0,0 +1,259 @@ +# coding: utf-8 +# Copyright (c) ICAMS, Ruhr University Bochum, 2022 + +## Executable required: $pyiron/resources/pacemaker/bin/run_pacemaker_tf_cpu.sh AND run_pacemaker_tf.sh + + +import logging +import numpy as np +import os +import pandas as pd +import re +import ruamel.yaml as yaml + +from shutil import copyfile + +from pyiron_base import GenericJob, GenericParameters, state, Executable, FlattenedStorage + +from pyiron_contrib.atomistics.atomistics.job.trainingcontainer import TrainingStorage, TrainingContainer +from pyiron_contrib.atomistics.ml.potentialfit import PotentialFit + +s = state.settings + +# set loggers +loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] +for logger in loggers: + logger.setLevel(logging.WARNING) + + +#TODO: maybe need better name +class Pacemaker2022(GenericJob, PotentialFit): + + def __init__(self, project, job_name): + super().__init__(project, job_name) + self.__name__ = "Pacemaker2022" + self.__version__ = "0.2" + + self._job_dict = {} + + self.input = GenericParameters(table_name="input") + self.input['cutoff'] = 7. + self.input['metadata'] = {'comment': 'pyiron-generated fitting job'} + self.input['data'] = {} # data_config + self.input['potential'] = {} # potential_config + self.input['fit'] = {} # fit_config + self.input['backend'] = {'evaluator': 'tensorpot'} # backend_config + + self.structure_data = None + + # self.executable = "pacemaker input.yaml -l log.txt" + self._executable = None + self._executable_activate() + + state.publications.add(self.publication) + + @property + def publication(self): + return { + "pacemaker": [ + { + "title": "Efficient parametrization of the atomic cluster expansion", + "journal": "Physical Review Materials", + "volume": "6", + "number": "1", + "year": "2022", + "doi": "10.1103/PhysRevMaterials.6.013804", + "url": "https://doi.org/10.1103/PhysRevMaterials.6.013804", + "author": ["Anton Bochkarev", "Yury Lysogorskiy", "Sarath Menon", "Minaam Qamar", "Matous Mrovec", + "Ralf Drautz"], + }, + + { + "title": "Performant implementation of the atomic cluster expansion (PACE) and application to copper and silicon", + "journal": "npj Computational Materials", + "volume": "7", + "number": "1", + "year": "2021", + "doi": "10.1038/s41524-021-00559-9", + "url": "https://doi.org/10.1038/s41524-021-00559-9", + "author": ["Yury Lysogorskiy", "Cas van der Oord", "Anton Bochkarev", "Sarath Menon", + "Matteo Rinaldi", + "Thomas Hammerschmidt", "Matous Mrovec", "Aidan Thompson", "Gábor Csányi", + "Christoph Ortner", + "Ralf Drautz"], + }, + { + "title": "Atomic cluster expansion for accurate and transferable interatomic potentials", + "journal": "Physical Review B", + "volume": "99", + "year": "2019", + "doi": "10.1103/PhysRevB.99.014104", + "url": "https://doi.org/10.1103/PhysRevB.99.014104", + "author": ["Ralf Drautz"], + }, + ] + } + + # TODO: rewrite? + def _save_structure_dataframe_pckl_gzip(self, df): + df.rename(columns={"number_of_atoms": "NUMBER_OF_ATOMS", + "energy": "energy_corrected", + "atoms": "ase_atoms"}, inplace=True) + df["NUMBER_OF_ATOMS"] = df["NUMBER_OF_ATOMS"].astype(int) + if "pbc" not in df.columns: + df["pbc"] = df["ase_atoms"].map(lambda atoms: np.all(atoms.pbc)) + + data_file_name = os.path.join(self.working_directory, "df_fit.pckl.gzip") + logging.info("Saving training structures dataframe into {} with pickle protocol = 4, compression = gzip".format( + data_file_name)) + df.to_pickle(data_file_name, compression="gzip", protocol=4) + return data_file_name + + def write_input(self): + # prepare datafile + if self.structure_data is None: + raise ValueError( + "`structure_data` is none, but should be pd.DataFrame, TrainingContainer or valid pickle.gzip filename") + if isinstance(self.structure_data, pd.DataFrame): + logging.info("structure_data is pandas.DataFrame") + data_file_name = self._save_structure_dataframe_pckl_gzip(self.structure_data) + self.input["data"] = {"filename": data_file_name} + elif isinstance(self.structure_data, str): # filename + if os.path.isfile(self.structure_data): + logging.info("structure_data is valid file path") + self.input["data"] = {"filename": self.structure_data} + else: + raise ValueError("Provided structure_data filename ({}) doesn't exists".format(self.structure_data)) + elif hasattr(self.structure_data, "get_pandas"): # duck-typing check for TrainingContainer + logging.info("structure_data is TrainingContainer") + df = self.structure_data.to_pandas() + data_file_name = self._save_structure_dataframe_pckl_gzip(df) + self.input["data"] = {"filename": data_file_name} + elif self._training_ids: + logging.info("structure_data is from another pyiron jobs") + + metadata_dict = self.input["metadata"] + metadata_dict["pyiron_job_id"] = str(self.job_id) + + input_yaml_dict = { + "cutoff": self.input["cutoff"], + "metadata": metadata_dict, + 'potential': self.input['potential'], + 'data': self.input["data"], + 'fit': self.input["fit"], + 'backend': self.input["backend"], + } + + if isinstance(self.input["potential"], str): + pot_file_name = self.input["potential"] + if os.path.isfile(pot_file_name): + logging.info("Input potential is filename") + pot_basename = os.path.basename(pot_file_name) + copyfile(pot_file_name, os.path.join(self.working_directory, pot_basename)) + input_yaml_dict['potential'] = pot_basename + else: + raise ValueError("Provided potential filename ({}) doesn't exists".format(self.input["potential"])) + + with open(os.path.join(self.working_directory, "input.yaml"), "w") as f: + yaml.dump(input_yaml_dict, f) + + + def _analyse_log(self, logfile="metrics.txt"): + metrics_filename = os.path.join(self.working_directory, logfile) + + metrics_df = pd.read_csv(metrics_filename, sep="\s+") + res_dict = metrics_df.to_dict(orient="list") + return res_dict + + def collect_output(self): + final_potential_filename_yaml = self.get_final_potential_filename() + with open(final_potential_filename_yaml, "r") as f: + yaml_lines = f.readlines() + final_potential_yaml_string = "".join(yaml_lines) + + final_potential_filename_yace = self.get_final_potential_filename_ace() + # os.system("pace_yaml2yace {}".format(final_potential_filename_yaml)) + + with open(self.get_final_potential_filename_ace(), "r") as f: + ace_lines = f.readlines() + final_potential_yace_string = "".join(ace_lines) + + with open(self.get_final_potential_filename_ace(), "r") as f: + yace_data = yaml.safe_load(f) + + elements_name = yace_data["elements"] + + with self.project_hdf5.open("output/potential") as h5out: + h5out["yaml"] = final_potential_yaml_string + h5out["yace"] = final_potential_yace_string + h5out["elements_name"] = elements_name + + log_res_dict = self._analyse_log() + + with self.project_hdf5.open("output/log") as h5out: + for key, arr in log_res_dict.items(): + h5out[key] = arr + + def get_lammps_potential(self): + elements_name = self["output/potential/elements_name"] + elem = " ".join(elements_name) + pot_file_name = self.get_final_potential_filename_ace() + pot_dict = { + 'Config': [["pair_style pace\n", "pair_coeff * * {} {}\n".format(pot_file_name, elem)]], + 'Filename': [""], + 'Model': ["ACE"], + 'Name': [self.job_name], + 'Species': [elements_name] + } + + ace_potential = pd.DataFrame(pot_dict) + + return ace_potential + + def to_hdf(self, hdf=None, group_name=None): + super().to_hdf( + hdf=hdf, + group_name=group_name + ) + with self.project_hdf5.open("input") as h5in: + self.input.to_hdf(h5in) + + def from_hdf(self, hdf=None, group_name=None): + super().from_hdf( + hdf=hdf, + group_name=group_name + ) + with self.project_hdf5.open("input") as h5in: + self.input.from_hdf(h5in) + + def get_final_potential_filename(self): + return os.path.join(self.working_directory, "output_potential.yaml") + + def get_final_potential_filename_ace(self): + return os.path.join(self.working_directory, "output_potential.yace") + + def get_current_potential_filename(self): + return os.path.join(self.working_directory, "interim_potential_0.yaml") + + # To link to the executable from the notebook + def _executable_activate(self, enforce=False): + if self._executable is None or enforce: + self._executable = Executable( + codename="pacemaker", module="pacemaker", path_binary_codes=state.settings.resource_paths + ) + + def _add_training_data(self, container: TrainingContainer) -> None: + self.add_job_to_fitting(container.id, 0, container.number_of_structures - 1, 1) + + def add_job_to_fitting(self, job_id, time_step_start=0, time_step_end=-1, time_step_delta=10): + if time_step_end == -1: + time_step_end = np.shape(self.project.inspect(int(job_id))['output/generic/cells'])[0] - 1 + self._job_dict[job_id] = {'time_step_start': time_step_start, + 'time_step_end': time_step_end, + 'time_step_delta': time_step_delta} + + def _get_training_data(self) -> TrainingStorage: + raise NotImplementedError() + + def _get_predicted_data(self) -> FlattenedStorage: + raise NotImplementedError() From 53ba58cf83b7e82d1cf7080bbaacdab17fa2ef65 Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Fri, 20 May 2022 16:04:04 +0200 Subject: [PATCH 2/8] WIP: elif self._job_dict: raise NotImplementedError() --- pyiron_contrib/atomistics/pacemaker/job.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py index 93302c0f2..74c08958e 100644 --- a/pyiron_contrib/atomistics/pacemaker/job.py +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -129,8 +129,8 @@ def write_input(self): df = self.structure_data.to_pandas() data_file_name = self._save_structure_dataframe_pckl_gzip(df) self.input["data"] = {"filename": data_file_name} - elif self._training_ids: - logging.info("structure_data is from another pyiron jobs") + elif self._job_dict: + raise NotImplementedError() metadata_dict = self.input["metadata"] metadata_dict["pyiron_job_id"] = str(self.job_id) From b89fe5d519d7eeaa2ad7fffb2e4cfd8249b27d40 Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Tue, 24 May 2022 17:04:19 +0200 Subject: [PATCH 3/8] Pacemaker job: - add elements and cutoff properties - set default self.input - rewrite _save_structure_dataframe_pckl_gzip - write_input: if _train_job_id_list is non empty, after adding job.add_training_data(training_container), then compose training dataframe using 'job.create_training_dataframe' - automatically determine the list of elements if self.structure_data is pd.DataFrame - implement _get_training_data and _get_predicted_data --- pyiron_contrib/atomistics/pacemaker/job.py | 177 ++++++++++++++++----- 1 file changed, 140 insertions(+), 37 deletions(-) diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py index 74c08958e..66add2877 100644 --- a/pyiron_contrib/atomistics/pacemaker/job.py +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -3,12 +3,12 @@ ## Executable required: $pyiron/resources/pacemaker/bin/run_pacemaker_tf_cpu.sh AND run_pacemaker_tf.sh - import logging +from typing import List + import numpy as np import os import pandas as pd -import re import ruamel.yaml as yaml from shutil import copyfile @@ -18,6 +18,9 @@ from pyiron_contrib.atomistics.atomistics.job.trainingcontainer import TrainingStorage, TrainingContainer from pyiron_contrib.atomistics.ml.potentialfit import PotentialFit +from pyiron_atomistics.atomistics.structure.atoms import Atoms as pyironAtoms +from ase.atoms import Atoms as aseAtoms + s = state.settings # set loggers @@ -26,7 +29,7 @@ logger.setLevel(logging.WARNING) -#TODO: maybe need better name +# TODO: maybe need better rename to Pacemaker class Pacemaker2022(GenericJob, PotentialFit): def __init__(self, project, job_name): @@ -34,24 +37,79 @@ def __init__(self, project, job_name): self.__name__ = "Pacemaker2022" self.__version__ = "0.2" - self._job_dict = {} + self._train_job_id_list = [] self.input = GenericParameters(table_name="input") - self.input['cutoff'] = 7. + self._cutoff = 7.0 + self.input['cutoff'] = self._cutoff self.input['metadata'] = {'comment': 'pyiron-generated fitting job'} - self.input['data'] = {} # data_config - self.input['potential'] = {} # potential_config - self.input['fit'] = {} # fit_config - self.input['backend'] = {'evaluator': 'tensorpot'} # backend_config - self.structure_data = None + # data_config + self.input['data'] = {} + # potential_config + self.input['potential'] = { + "elements": [], + "bonds": { + "ALL": { + "radbase": "SBessel", + "rcut": self._cutoff, + "dcut": 0.01, + "radparameters": [5.25] + } + }, + + "embeddings": { + "ALL": { + "fs_parameters": [1, 1, 1, 0.5], + "ndensity": 2, + "npot": "FinnisSinclairShiftedScaled" + } + }, + + "functions": { + "ALL": { + "nradmax_by_orders": [15, 3, 2, 1], + "lmax_by_orders": [0, 3, 2, 1], + } + } + } + + # fit_config + self.input['fit'] = { + "loss": {"L1_coeffs": 1e-8, "L2_coeffs": 1e-8, "kappa": 0.3, "w0_rad": 0, + "w1_rad": 0, "w2_rad": 0}, + "maxiter": 1000, + "optimizer": "BFGS", + "fit_cycles": 1 + } + self.input['backend'] = {"batch_size": 100, + "display_step": 50, + "evaluator": "tensorpot"} # backend_config - # self.executable = "pacemaker input.yaml -l log.txt" + self.structure_data = None self._executable = None self._executable_activate() state.publications.add(self.publication) + @property + def elements(self): + return self.input["potential"].get("elements") + + @elements.setter + def elements(self, val): + self.input["potential"]["elements"] = val + + @property + def cutoff(self): + return self._cutoff + + @cutoff.setter + def cutoff(self, val): + self._cutoff = val + self.input["cutoff"] = self._cutoff + self.input["potential"]["bonds"]["ALL"]["rcut"] = self._cutoff + @property def publication(self): return { @@ -94,12 +152,31 @@ def publication(self): ] } - # TODO: rewrite? def _save_structure_dataframe_pckl_gzip(self, df): - df.rename(columns={"number_of_atoms": "NUMBER_OF_ATOMS", - "energy": "energy_corrected", - "atoms": "ase_atoms"}, inplace=True) + + if "NUMBER_OF_ATOMS" not in df.columns and "number_of_atoms" in df.columns: + df.rename(columns={"number_of_atoms": "NUMBER_OF_ATOMS"}, inplace=True) df["NUMBER_OF_ATOMS"] = df["NUMBER_OF_ATOMS"].astype(int) + + # TODO: reference energy subtraction ? + if "energy_corrected" not in df.columns and "energy" in df.columns: + df.rename(columns={"energy": "energy_corrected"}, inplace=True) + + if "atoms" in df.columns: + # check if this is pyironAtoms -> aseAtoms + at = df.iloc[0]["atoms"] + if isinstance(at, pyironAtoms): + df["ase_atoms"] = df["atoms"].map(lambda s: s.to_ase()) + df.drop(columns=["atoms"], inplace=True) + else: + assert isinstance(at, aseAtoms), "'atoms' column is not a valid ASE Atoms object" + df.rename(columns={"atoms": "ase_atom"}, inplace=True) + elif "ase_atoms" not in df.columns: + raise ValueError("DataFrame should contain 'atoms' (pyiron Atoms) or 'ase_atoms' (ASE atoms) columns") + + if "stress" in df.columns: + df.drop(columns=["stress"], inplace=True) + if "pbc" not in df.columns: df["pbc"] = df["ase_atoms"].map(lambda atoms: np.all(atoms.pbc)) @@ -111,13 +188,20 @@ def _save_structure_dataframe_pckl_gzip(self, df): def write_input(self): # prepare datafile - if self.structure_data is None: - raise ValueError( - "`structure_data` is none, but should be pd.DataFrame, TrainingContainer or valid pickle.gzip filename") + if self._train_job_id_list and self.structure_data is None: + train_df = self.create_training_dataframe(self._train_job_id_list) + self.structure_data = train_df + if isinstance(self.structure_data, pd.DataFrame): logging.info("structure_data is pandas.DataFrame") data_file_name = self._save_structure_dataframe_pckl_gzip(self.structure_data) self.input["data"] = {"filename": data_file_name} + elements_set = set() + for at in self.structure_data["ase_atoms"]: + elements_set.update(at.get_chemical_symbols()) + elements = sorted(elements_set) + print("Set automatically determined list of elements: {}".format(elements)) + self.elements = elements elif isinstance(self.structure_data, str): # filename if os.path.isfile(self.structure_data): logging.info("structure_data is valid file path") @@ -129,8 +213,9 @@ def write_input(self): df = self.structure_data.to_pandas() data_file_name = self._save_structure_dataframe_pckl_gzip(df) self.input["data"] = {"filename": data_file_name} - elif self._job_dict: - raise NotImplementedError() + elif self.structure_data is None: + raise ValueError( + "`structure_data` is none, but should be pd.DataFrame, TrainingContainer or valid pickle.gzip filename") metadata_dict = self.input["metadata"] metadata_dict["pyiron_job_id"] = str(self.job_id) @@ -138,9 +223,9 @@ def write_input(self): input_yaml_dict = { "cutoff": self.input["cutoff"], "metadata": metadata_dict, - 'potential': self.input['potential'], - 'data': self.input["data"], - 'fit': self.input["fit"], + "potential": self.input["potential"], + "data": self.input["data"], + "fit": self.input["fit"], 'backend': self.input["backend"], } @@ -157,7 +242,6 @@ def write_input(self): with open(os.path.join(self.working_directory, "input.yaml"), "w") as f: yaml.dump(input_yaml_dict, f) - def _analyse_log(self, logfile="metrics.txt"): metrics_filename = os.path.join(self.working_directory, logfile) @@ -171,8 +255,6 @@ def collect_output(self): yaml_lines = f.readlines() final_potential_yaml_string = "".join(yaml_lines) - final_potential_filename_yace = self.get_final_potential_filename_ace() - # os.system("pace_yaml2yace {}".format(final_potential_filename_yaml)) with open(self.get_final_potential_filename_ace(), "r") as f: ace_lines = f.readlines() @@ -236,24 +318,45 @@ def get_current_potential_filename(self): return os.path.join(self.working_directory, "interim_potential_0.yaml") # To link to the executable from the notebook - def _executable_activate(self, enforce=False): + def _executable_activate(self, enforce=False, codename="pacemaker"): if self._executable is None or enforce: self._executable = Executable( - codename="pacemaker", module="pacemaker", path_binary_codes=state.settings.resource_paths + codename=codename, module="pacemaker", path_binary_codes=state.settings.resource_paths ) def _add_training_data(self, container: TrainingContainer) -> None: - self.add_job_to_fitting(container.id, 0, container.number_of_structures - 1, 1) + self.add_job_to_fitting(container.id) - def add_job_to_fitting(self, job_id, time_step_start=0, time_step_end=-1, time_step_delta=10): - if time_step_end == -1: - time_step_end = np.shape(self.project.inspect(int(job_id))['output/generic/cells'])[0] - 1 - self._job_dict[job_id] = {'time_step_start': time_step_start, - 'time_step_end': time_step_end, - 'time_step_delta': time_step_delta} + def add_job_to_fitting(self, job_id, *args, **kwargs): + self._train_job_id_list.append(job_id) def _get_training_data(self) -> TrainingStorage: - raise NotImplementedError() + # TODO: convert to TrainingStorage ? + fname = os.path.join(self.working_directory, "fitting_data_info.pckl.gzip") + df = pd.read_pickle(fname, compression="gzip") + return df def _get_predicted_data(self) -> FlattenedStorage: - raise NotImplementedError() + # TODO: convert to FlattenedStorage ? + fname = os.path.join(self.working_directory, "train_pred.pckl.gzip") + df = pd.read_pickle(fname, compression="gzip") + return df + + # copied/adapted from mlip.py + def create_training_dataframe(self, _train_job_id_list: List = None) -> pd.DataFrame: + if _train_job_id_list is None: + _train_job_id_list = self._train_job_id_list + df_list = [] + for job_id in _train_job_id_list: + ham = self.project.inspect(job_id) + if ham.__name__ == "TrainingContainer": + job = ham.to_object() + data_df = job.to_pandas() + df_list.append(data_df) + else: + raise NotImplementedError("Currently only TrainingContainer is supported") + + total_training_df = pd.concat(df_list, axis=0) + total_training_df.reset_index(drop=True, inplace=True) + + return total_training_df From 37f85d985767466899da9a602527b7dc4827243f Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Tue, 24 May 2022 17:12:15 +0200 Subject: [PATCH 4/8] rename Pacemaker2022 to PacemakerJob --- pyiron_contrib/__init__.py | 2 +- pyiron_contrib/atomistics/pacemaker/job.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyiron_contrib/__init__.py b/pyiron_contrib/__init__.py index 71715401f..e4842e156 100644 --- a/pyiron_contrib/__init__.py +++ b/pyiron_contrib/__init__.py @@ -44,7 +44,7 @@ JOB_CLASS_DICT['Atomicrex'] = 'pyiron_contrib.atomistics.atomicrex.atomicrex_job' JOB_CLASS_DICT['StructureMasterInt'] = 'pyiron_contrib.atomistics.atomistics.job.structurelistmasterinteractive' JOB_CLASS_DICT['StorageJob'] = 'pyiron_contrib.RDM.storagejob' -JOB_CLASS_DICT['Pacemaker2022'] = 'pyiron_contrib.atomistics.pacemaker.job' +JOB_CLASS_DICT['PacemakerJob'] = 'pyiron_contrib.atomistics.pacemaker.job' from ._version import get_versions diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py index 66add2877..36f9593c1 100644 --- a/pyiron_contrib/atomistics/pacemaker/job.py +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -30,7 +30,7 @@ # TODO: maybe need better rename to Pacemaker -class Pacemaker2022(GenericJob, PotentialFit): +class PacemakerJob(GenericJob, PotentialFit): def __init__(self, project, job_name): super().__init__(project, job_name) From 14e2ccc55ffc273b5c0ce28b22e471442a9a897b Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Tue, 24 May 2022 17:53:45 +0200 Subject: [PATCH 5/8] add pacemaker_example.ipynb --- notebooks/pacemaker_example.ipynb | 809 +++++++++++++++++++++ pyiron_contrib/atomistics/pacemaker/job.py | 1 - 2 files changed, 809 insertions(+), 1 deletion(-) create mode 100644 notebooks/pacemaker_example.ipynb diff --git a/notebooks/pacemaker_example.ipynb b/notebooks/pacemaker_example.ipynb new file mode 100644 index 000000000..a3cd4f501 --- /dev/null +++ b/notebooks/pacemaker_example.ipynb @@ -0,0 +1,809 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f4eaae76", + "metadata": {}, + "source": [ + "# Pre-requisites\n", + "\n", + "1. Install [`python-ace`](https://github.com/ICAMS/python-ace) and [`tensorpotential`](https://github.com/ICAMS/TensorPotential), check more instructions [here](https://pacemaker.readthedocs.io/en/latest/pacemaker/install/) into pyiron conda environment\n", + "\n", + "2. Add following files into `~/pyiron/resources/pacemaker/bin`:\n", + "\n", + "**~/pyiron/resources/pacemaker/bin/run_pacemaker_tf.sh**:\n", + "```bash\n", + "#!/bin/bash\n", + "\n", + "source $HOME/.bashrc\n", + "conda activate PYIRON_AND_PACEMAKER_CONDA_ENVIRONMENT\n", + "TF_FORCE_GPU_ALLOW_GROWTH=true pacemaker input.yaml -l log.txt\n", + "pace_yaml2yace output_potential.yaml\n", + "```\n", + "\n", + "**~/pyiron/resources/pacemaker/bin/run_pacemaker_tf_cpu.sh**:\n", + "```bash\n", + "#!/bin/bash\n", + "\n", + "source $HOME/.bashrc\n", + "conda activate PYIRON_AND_PACEMAKER_CONDA_ENVIRONMENT\n", + "CUDA_VISIBLE_DEVICES=-1 pacemaker input.yaml -l log.txt\n", + "pace_yaml2yace output_potential.yaml\n", + "\n", + "```\n", + "\n", + "or get it from https://github.com/pyiron/pyiron-resources" + ] + }, + { + "cell_type": "markdown", + "id": "180f4a44", + "metadata": {}, + "source": [ + "# Import and load" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a24477d0", + "metadata": {}, + "outputs": [], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d19586ef", + "metadata": {}, + "outputs": [], + "source": [ + "from pyiron import Project" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "78425c8c", + "metadata": {}, + "outputs": [], + "source": [ + "pr = Project('fit_project')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dc7ef7ee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idstatuschemicalformulajobsubjobprojectpathprojecttimestarttimestoptotalcputimecomputerhamiltonhamversionparentidmasterid
02finishedNoneinitial/initialNone/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/2022-05-20 07:33:26.696857NoneNonezora@cmti001#1TrainingContainer0.4NoneNone
13finishedNoneoffstoichiometry/offstoichiometryNone/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/2022-05-20 07:40:54.302418NoneNonezora@cmti001#1TrainingContainer0.4NoneNone
\n", + "
" + ], + "text/plain": [ + " id status chemicalformula job subjob \\\n", + "0 2 finished None initial /initial \n", + "1 3 finished None offstoichiometry /offstoichiometry \n", + "\n", + " projectpath \\\n", + "0 None \n", + "1 None \n", + "\n", + " project \\\n", + "0 /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/ \n", + "1 /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/ \n", + "\n", + " timestart timestop totalcputime computer \\\n", + "0 2022-05-20 07:33:26.696857 None None zora@cmti001#1 \n", + "1 2022-05-20 07:40:54.302418 None None zora@cmti001#1 \n", + "\n", + " hamilton hamversion parentid masterid \n", + "0 TrainingContainer 0.4 None None \n", + "1 TrainingContainer 0.4 None None " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pr.job_table()" + ] + }, + { + "cell_type": "markdown", + "id": "be711442", + "metadata": {}, + "source": [ + "# Loading training containers" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e8588cf3", + "metadata": {}, + "outputs": [], + "source": [ + "training_container_1 = pr['initial/initial']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "05ea947a", + "metadata": {}, + "outputs": [], + "source": [ + "training_container_2 = pr['initial/offstoichiometry']" + ] + }, + { + "cell_type": "markdown", + "id": "5ddc4df8", + "metadata": {}, + "source": [ + "# Create PacemakerJob" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "932a7b46", + "metadata": {}, + "outputs": [], + "source": [ + "job = pr.create_job(pr.job_type.PacemakerJob, \"pacemaker_job\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6bd31372", + "metadata": {}, + "outputs": [], + "source": [ + "job.add_training_data(training_container_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6b8edcef", + "metadata": {}, + "outputs": [], + "source": [ + "job.add_training_data(training_container_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "180d92d9", + "metadata": {}, + "outputs": [], + "source": [ + "# set cutoff\n", + "job.cutoff=7.0" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "b25f83e8", + "metadata": {}, + "outputs": [], + "source": [ + "# set number of iterations\n", + "job.input[\"fit\"][\"maxiter\"]=1000" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "f9d67b89", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParameterValueComment
0cutoff7.0
1metadata{'comment': 'pyiron-generated fitting job', 'pyiron_job_id': '4'}
2data{'filename': '/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/df_fit.pckl.gzip'}
3potential{'elements': ['Al', 'Li'], 'bonds': {'ALL': {'radbase': 'SBessel', 'rcut': 7.0, 'dcut': 0.01, 'radparameters': [5.25]}}, 'embeddings': {'ALL': {'fs_parameters': [1, 1, 1, 0.5], 'ndensity': 2, 'npo...
4fit{'loss': {'L1_coeffs': 1e-08, 'L2_coeffs': 1e-08, 'kappa': 0.3, 'w0_rad': 0, 'w1_rad': 0, 'w2_rad': 0}, 'maxiter': 1000, 'optimizer': 'BFGS', 'fit_cycles': 1}
5backend{'batch_size': 100, 'display_step': 50, 'evaluator': 'tensorpot'}
\n", + "
" + ], + "text/plain": [ + " Parameter \\\n", + "0 cutoff \n", + "1 metadata \n", + "2 data \n", + "3 potential \n", + "4 fit \n", + "5 backend \n", + "\n", + " Value \\\n", + "0 7.0 \n", + "1 {'comment': 'pyiron-generated fitting job', 'pyiron_job_id': '4'} \n", + "2 {'filename': '/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/df_fit.pckl.gzip'} \n", + "3 {'elements': ['Al', 'Li'], 'bonds': {'ALL': {'radbase': 'SBessel', 'rcut': 7.0, 'dcut': 0.01, 'radparameters': [5.25]}}, 'embeddings': {'ALL': {'fs_parameters': [1, 1, 1, 0.5], 'ndensity': 2, 'npo... \n", + "4 {'loss': {'L1_coeffs': 1e-08, 'L2_coeffs': 1e-08, 'kappa': 0.3, 'w0_rad': 0, 'w1_rad': 0, 'w2_rad': 0}, 'maxiter': 1000, 'optimizer': 'BFGS', 'fit_cycles': 1} \n", + "5 {'batch_size': 100, 'display_step': 50, 'evaluator': 'tensorpot'} \n", + "\n", + " Comment \n", + "0 \n", + "1 \n", + "2 \n", + "3 \n", + "4 \n", + "5 " + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "job.input" + ] + }, + { + "cell_type": "markdown", + "id": "18f2a543", + "metadata": {}, + "source": [ + "# Run fit" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "4bff02a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set automatically determined list of elements: ['Al', 'Li']\n", + "The job pacemaker_job was saved and received the ID: 4\n" + ] + } + ], + "source": [ + "job.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "58687533", + "metadata": {}, + "outputs": [], + "source": [ + "job.collect_output()" + ] + }, + { + "cell_type": "markdown", + "id": "27f90579", + "metadata": {}, + "source": [ + "# Analyse fit" + ] + }, + { + "cell_type": "markdown", + "id": "30654b6e", + "metadata": {}, + "source": [ + "plot loss function" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "1640ba96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(job[\"output/log/loss\"])\n", + "plt.xlabel(\"# iter\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.loglog()" + ] + }, + { + "cell_type": "markdown", + "id": "4e8d5e7d", + "metadata": {}, + "source": [ + "plot energy per atom RMSE" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "9c52dd86", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(job[\"output/log/rmse_epa\"])\n", + "plt.xlabel(\"# iter\")\n", + "plt.ylabel(\"RMSE E, eV/atom\")\n", + "plt.loglog()" + ] + }, + { + "cell_type": "markdown", + "id": "ae6c3689", + "metadata": {}, + "source": [ + "plot force component RMSE" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "e55598f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(job[\"output/log/rmse_f_comp\"])\n", + "plt.xlabel(\"# iter\")\n", + "plt.ylabel(\"RMSE F_i, eV/A\")\n", + "plt.loglog()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f09f50f6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f23dd5c8", + "metadata": {}, + "source": [ + "load DataFrame with predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "0acc3ed8", + "metadata": {}, + "outputs": [], + "source": [ + "pred_df = job.predicted_data" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "604da991", + "metadata": {}, + "outputs": [], + "source": [ + "pred_df[\"energy_pred_per_atom\"] = pred_df[\"energy_pred\"]/pred_df[\"NUMBER_OF_ATOMS\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "0456dfe6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'ACE E, eV/atom')" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pred_df[\"energy_corrected_per_atom\"], pred_df[\"energy_pred_per_atom\"])\n", + "plt.xlabel(\"DFT E, eV/atom\")\n", + "plt.ylabel(\"ACE E, eV/atom\")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "07e559d1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'ACE F_i, eV/A')" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(np.vstack(pred_df[\"forces\"]), np.vstack(pred_df[\"forces_pred\"]))\n", + "plt.xlabel(\"DFT F_i, eV/A\")\n", + "plt.ylabel(\"ACE F_i, eV/A\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43303071", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "a400fd18", + "metadata": {}, + "source": [ + "Check more in `job.working_directory`/report folder" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "06ddc750", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_E-dE-dist.png train_EF-pairplots.png train_Fi-dFi-dist.png\r\n", + "train_E-dE-nn.png train_F-dF-dist.png\r\n" + ] + } + ], + "source": [ + "! ls {job.working_directory}/report" + ] + }, + { + "cell_type": "markdown", + "id": "aeea434a", + "metadata": {}, + "source": [ + "# Get LAMMPS potential " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "a739431f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ConfigFilenameModelNameSpecies
0[pair_style pace\\n, pair_coeff * * /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/output_potential.yace Al Li\\n]ACEpacemaker_job[Al, Li]
\n", + "
" + ], + "text/plain": [ + " Config \\\n", + "0 [pair_style pace\\n, pair_coeff * * /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/output_potential.yace Al Li\\n] \n", + "\n", + " Filename Model Name Species \n", + "0 ACE pacemaker_job [Al, Li] " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lammps_potential = job.get_lammps_potential()\n", + "lammps_potential" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d6534da", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (pyiron2022)", + "language": "python", + "name": "pyiron2022" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py index 36f9593c1..d35ce616a 100644 --- a/pyiron_contrib/atomistics/pacemaker/job.py +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -29,7 +29,6 @@ logger.setLevel(logging.WARNING) -# TODO: maybe need better rename to Pacemaker class PacemakerJob(GenericJob, PotentialFit): def __init__(self, project, job_name): From bc48b0b26f977a2e282e80649414705a872d99bc Mon Sep 17 00:00:00 2001 From: Yury Lysogorskiy Date: Wed, 1 Jun 2022 18:59:55 +0200 Subject: [PATCH 6/8] removed log setters extract training_data(TrainingStorage) and predicted_data_fs(FlattenedStorage) in collect_output --- pyiron_contrib/atomistics/pacemaker/job.py | 57 ++++++++++++++++------ 1 file changed, 42 insertions(+), 15 deletions(-) diff --git a/pyiron_contrib/atomistics/pacemaker/job.py b/pyiron_contrib/atomistics/pacemaker/job.py index d35ce616a..74bb2d3e1 100644 --- a/pyiron_contrib/atomistics/pacemaker/job.py +++ b/pyiron_contrib/atomistics/pacemaker/job.py @@ -18,16 +18,11 @@ from pyiron_contrib.atomistics.atomistics.job.trainingcontainer import TrainingStorage, TrainingContainer from pyiron_contrib.atomistics.ml.potentialfit import PotentialFit -from pyiron_atomistics.atomistics.structure.atoms import Atoms as pyironAtoms +from pyiron_atomistics.atomistics.structure.atoms import Atoms as pyironAtoms, ase_to_pyiron from ase.atoms import Atoms as aseAtoms s = state.settings -# set loggers -loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] -for logger in loggers: - logger.setLevel(logging.WARNING) - class PacemakerJob(GenericJob, PotentialFit): @@ -254,7 +249,6 @@ def collect_output(self): yaml_lines = f.readlines() final_potential_yaml_string = "".join(yaml_lines) - with open(self.get_final_potential_filename_ace(), "r") as f: ace_lines = f.readlines() final_potential_yace_string = "".join(ace_lines) @@ -275,6 +269,45 @@ def collect_output(self): for key, arr in log_res_dict.items(): h5out[key] = arr + # training data + training_data_fname = os.path.join(self.working_directory, "fitting_data_info.pckl.gzip") + df = pd.read_pickle(training_data_fname, compression="gzip") + df["atoms"] = df.ase_atoms.map(ase_to_pyiron) + training_data_ts = TrainingStorage() + for _, r in df.iterrows(): + training_data_ts.add_structure(r.atoms, + energy=r.energy_corrected, + forces=r.forces, + identifier=r['name']) + + # predicted data + predicted_fname = os.path.join(self.working_directory, "train_pred.pckl.gzip") + df = pd.read_pickle(predicted_fname, compression="gzip") + predicted_data_fs = FlattenedStorage() + predicted_data_fs.add_array('energy', dtype=np.float64, shape=(), per='chunk') + predicted_data_fs.add_array('energy_true', dtype=np.float64, shape=(), per='chunk') + + predicted_data_fs.add_array('number_of_atoms', dtype=np.int, shape=(), per='chunk') + + predicted_data_fs.add_array('forces', dtype=np.float64, shape=(3,), per='element') + predicted_data_fs.add_array('forces_true', dtype=np.float64, shape=(3,), per='element') + for i, r in df.iterrows(): + identifier = r['name'] if "name" in r else str(i) + predicted_data_fs.add_chunk(r["NUMBER_OF_ATOMS"], identifier=identifier, + energy=r.energy_pred, + forces=r.forces_pred, + energy_true=r.energy_corrected, + forces_true=r.forces, + number_of_atoms = r.NUMBER_OF_ATOMS, + + energy_per_atom = r.energy_pred / r.NUMBER_OF_ATOMS, + energy_per_atom_true=r.energy_corrected / r.NUMBER_OF_ATOMS, + ) + + with self.project_hdf5.open("output") as hdf5_output: + training_data_ts.to_hdf(hdf=hdf5_output, group_name="training_data") + predicted_data_fs.to_hdf(hdf=hdf5_output, group_name="predicted_data") + def get_lammps_potential(self): elements_name = self["output/potential/elements_name"] elem = " ".join(elements_name) @@ -330,16 +363,10 @@ def add_job_to_fitting(self, job_id, *args, **kwargs): self._train_job_id_list.append(job_id) def _get_training_data(self) -> TrainingStorage: - # TODO: convert to TrainingStorage ? - fname = os.path.join(self.working_directory, "fitting_data_info.pckl.gzip") - df = pd.read_pickle(fname, compression="gzip") - return df + return self["output/training_data"].to_object() def _get_predicted_data(self) -> FlattenedStorage: - # TODO: convert to FlattenedStorage ? - fname = os.path.join(self.working_directory, "train_pred.pckl.gzip") - df = pd.read_pickle(fname, compression="gzip") - return df + return self["output/predicted_data"].to_object() # copied/adapted from mlip.py def create_training_dataframe(self, _train_job_id_list: List = None) -> pd.DataFrame: From b05890fde200d1e2f80bd453a4b1d1e91cb4f1e9 Mon Sep 17 00:00:00 2001 From: Marvin Poul Date: Wed, 1 Jun 2022 21:16:24 +0200 Subject: [PATCH 7/8] Do not import from pyiron in example notebook --- notebooks/pacemaker_example.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/pacemaker_example.ipynb b/notebooks/pacemaker_example.ipynb index a3cd4f501..be6bc429c 100644 --- a/notebooks/pacemaker_example.ipynb +++ b/notebooks/pacemaker_example.ipynb @@ -60,7 +60,7 @@ "metadata": {}, "outputs": [], "source": [ - "from pyiron import Project" + "from pyiron_contrib import Project" ] }, { From c50a420efb7d314e463369f4bb8b4d48d0f6c897 Mon Sep 17 00:00:00 2001 From: Marvin Poul Date: Wed, 1 Jun 2022 21:47:14 +0200 Subject: [PATCH 8/8] Remove example notebook --- notebooks/pacemaker_example.ipynb | 809 ------------------------------ 1 file changed, 809 deletions(-) delete mode 100644 notebooks/pacemaker_example.ipynb diff --git a/notebooks/pacemaker_example.ipynb b/notebooks/pacemaker_example.ipynb deleted file mode 100644 index be6bc429c..000000000 --- a/notebooks/pacemaker_example.ipynb +++ /dev/null @@ -1,809 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f4eaae76", - "metadata": {}, - "source": [ - "# Pre-requisites\n", - "\n", - "1. Install [`python-ace`](https://github.com/ICAMS/python-ace) and [`tensorpotential`](https://github.com/ICAMS/TensorPotential), check more instructions [here](https://pacemaker.readthedocs.io/en/latest/pacemaker/install/) into pyiron conda environment\n", - "\n", - "2. Add following files into `~/pyiron/resources/pacemaker/bin`:\n", - "\n", - "**~/pyiron/resources/pacemaker/bin/run_pacemaker_tf.sh**:\n", - "```bash\n", - "#!/bin/bash\n", - "\n", - "source $HOME/.bashrc\n", - "conda activate PYIRON_AND_PACEMAKER_CONDA_ENVIRONMENT\n", - "TF_FORCE_GPU_ALLOW_GROWTH=true pacemaker input.yaml -l log.txt\n", - "pace_yaml2yace output_potential.yaml\n", - "```\n", - "\n", - "**~/pyiron/resources/pacemaker/bin/run_pacemaker_tf_cpu.sh**:\n", - "```bash\n", - "#!/bin/bash\n", - "\n", - "source $HOME/.bashrc\n", - "conda activate PYIRON_AND_PACEMAKER_CONDA_ENVIRONMENT\n", - "CUDA_VISIBLE_DEVICES=-1 pacemaker input.yaml -l log.txt\n", - "pace_yaml2yace output_potential.yaml\n", - "\n", - "```\n", - "\n", - "or get it from https://github.com/pyiron/pyiron-resources" - ] - }, - { - "cell_type": "markdown", - "id": "180f4a44", - "metadata": {}, - "source": [ - "# Import and load" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a24477d0", - "metadata": {}, - "outputs": [], - "source": [ - "%pylab inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d19586ef", - "metadata": {}, - "outputs": [], - "source": [ - "from pyiron_contrib import Project" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "78425c8c", - "metadata": {}, - "outputs": [], - "source": [ - "pr = Project('fit_project')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "dc7ef7ee", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idstatuschemicalformulajobsubjobprojectpathprojecttimestarttimestoptotalcputimecomputerhamiltonhamversionparentidmasterid
02finishedNoneinitial/initialNone/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/2022-05-20 07:33:26.696857NoneNonezora@cmti001#1TrainingContainer0.4NoneNone
13finishedNoneoffstoichiometry/offstoichiometryNone/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/2022-05-20 07:40:54.302418NoneNonezora@cmti001#1TrainingContainer0.4NoneNone
\n", - "
" - ], - "text/plain": [ - " id status chemicalformula job subjob \\\n", - "0 2 finished None initial /initial \n", - "1 3 finished None offstoichiometry /offstoichiometry \n", - "\n", - " projectpath \\\n", - "0 None \n", - "1 None \n", - "\n", - " project \\\n", - "0 /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/ \n", - "1 /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/initial/ \n", - "\n", - " timestart timestop totalcputime computer \\\n", - "0 2022-05-20 07:33:26.696857 None None zora@cmti001#1 \n", - "1 2022-05-20 07:40:54.302418 None None zora@cmti001#1 \n", - "\n", - " hamilton hamversion parentid masterid \n", - "0 TrainingContainer 0.4 None None \n", - "1 TrainingContainer 0.4 None None " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pr.job_table()" - ] - }, - { - "cell_type": "markdown", - "id": "be711442", - "metadata": {}, - "source": [ - "# Loading training containers" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "e8588cf3", - "metadata": {}, - "outputs": [], - "source": [ - "training_container_1 = pr['initial/initial']" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "05ea947a", - "metadata": {}, - "outputs": [], - "source": [ - "training_container_2 = pr['initial/offstoichiometry']" - ] - }, - { - "cell_type": "markdown", - "id": "5ddc4df8", - "metadata": {}, - "source": [ - "# Create PacemakerJob" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "932a7b46", - "metadata": {}, - "outputs": [], - "source": [ - "job = pr.create_job(pr.job_type.PacemakerJob, \"pacemaker_job\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "6bd31372", - "metadata": {}, - "outputs": [], - "source": [ - "job.add_training_data(training_container_1)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "6b8edcef", - "metadata": {}, - "outputs": [], - "source": [ - "job.add_training_data(training_container_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "180d92d9", - "metadata": {}, - "outputs": [], - "source": [ - "# set cutoff\n", - "job.cutoff=7.0" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "b25f83e8", - "metadata": {}, - "outputs": [], - "source": [ - "# set number of iterations\n", - "job.input[\"fit\"][\"maxiter\"]=1000" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "f9d67b89", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ParameterValueComment
0cutoff7.0
1metadata{'comment': 'pyiron-generated fitting job', 'pyiron_job_id': '4'}
2data{'filename': '/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/df_fit.pckl.gzip'}
3potential{'elements': ['Al', 'Li'], 'bonds': {'ALL': {'radbase': 'SBessel', 'rcut': 7.0, 'dcut': 0.01, 'radparameters': [5.25]}}, 'embeddings': {'ALL': {'fs_parameters': [1, 1, 1, 0.5], 'ndensity': 2, 'npo...
4fit{'loss': {'L1_coeffs': 1e-08, 'L2_coeffs': 1e-08, 'kappa': 0.3, 'w0_rad': 0, 'w1_rad': 0, 'w2_rad': 0}, 'maxiter': 1000, 'optimizer': 'BFGS', 'fit_cycles': 1}
5backend{'batch_size': 100, 'display_step': 50, 'evaluator': 'tensorpot'}
\n", - "
" - ], - "text/plain": [ - " Parameter \\\n", - "0 cutoff \n", - "1 metadata \n", - "2 data \n", - "3 potential \n", - "4 fit \n", - "5 backend \n", - "\n", - " Value \\\n", - "0 7.0 \n", - "1 {'comment': 'pyiron-generated fitting job', 'pyiron_job_id': '4'} \n", - "2 {'filename': '/home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/df_fit.pckl.gzip'} \n", - "3 {'elements': ['Al', 'Li'], 'bonds': {'ALL': {'radbase': 'SBessel', 'rcut': 7.0, 'dcut': 0.01, 'radparameters': [5.25]}}, 'embeddings': {'ALL': {'fs_parameters': [1, 1, 1, 0.5], 'ndensity': 2, 'npo... \n", - "4 {'loss': {'L1_coeffs': 1e-08, 'L2_coeffs': 1e-08, 'kappa': 0.3, 'w0_rad': 0, 'w1_rad': 0, 'w2_rad': 0}, 'maxiter': 1000, 'optimizer': 'BFGS', 'fit_cycles': 1} \n", - "5 {'batch_size': 100, 'display_step': 50, 'evaluator': 'tensorpot'} \n", - "\n", - " Comment \n", - "0 \n", - "1 \n", - "2 \n", - "3 \n", - "4 \n", - "5 " - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "job.input" - ] - }, - { - "cell_type": "markdown", - "id": "18f2a543", - "metadata": {}, - "source": [ - "# Run fit" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "4bff02a2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Set automatically determined list of elements: ['Al', 'Li']\n", - "The job pacemaker_job was saved and received the ID: 4\n" - ] - } - ], - "source": [ - "job.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "58687533", - "metadata": {}, - "outputs": [], - "source": [ - "job.collect_output()" - ] - }, - { - "cell_type": "markdown", - "id": "27f90579", - "metadata": {}, - "source": [ - "# Analyse fit" - ] - }, - { - "cell_type": "markdown", - "id": "30654b6e", - "metadata": {}, - "source": [ - "plot loss function" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "1640ba96", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(job[\"output/log/loss\"])\n", - "plt.xlabel(\"# iter\")\n", - "plt.ylabel(\"Loss\")\n", - "plt.loglog()" - ] - }, - { - "cell_type": "markdown", - "id": "4e8d5e7d", - "metadata": {}, - "source": [ - "plot energy per atom RMSE" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "9c52dd86", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(job[\"output/log/rmse_epa\"])\n", - "plt.xlabel(\"# iter\")\n", - "plt.ylabel(\"RMSE E, eV/atom\")\n", - "plt.loglog()" - ] - }, - { - "cell_type": "markdown", - "id": "ae6c3689", - "metadata": {}, - "source": [ - "plot force component RMSE" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "e55598f4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(job[\"output/log/rmse_f_comp\"])\n", - "plt.xlabel(\"# iter\")\n", - "plt.ylabel(\"RMSE F_i, eV/A\")\n", - "plt.loglog()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f09f50f6", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "f23dd5c8", - "metadata": {}, - "source": [ - "load DataFrame with predictions" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "0acc3ed8", - "metadata": {}, - "outputs": [], - "source": [ - "pred_df = job.predicted_data" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "604da991", - "metadata": {}, - "outputs": [], - "source": [ - "pred_df[\"energy_pred_per_atom\"] = pred_df[\"energy_pred\"]/pred_df[\"NUMBER_OF_ATOMS\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "0456dfe6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'ACE E, eV/atom')" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(pred_df[\"energy_corrected_per_atom\"], pred_df[\"energy_pred_per_atom\"])\n", - "plt.xlabel(\"DFT E, eV/atom\")\n", - "plt.ylabel(\"ACE E, eV/atom\")" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "07e559d1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'ACE F_i, eV/A')" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(np.vstack(pred_df[\"forces\"]), np.vstack(pred_df[\"forces_pred\"]))\n", - "plt.xlabel(\"DFT F_i, eV/A\")\n", - "plt.ylabel(\"ACE F_i, eV/A\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "43303071", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "a400fd18", - "metadata": {}, - "source": [ - "Check more in `job.working_directory`/report folder" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "06ddc750", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train_E-dE-dist.png train_EF-pairplots.png train_Fi-dFi-dist.png\r\n", - "train_E-dE-nn.png train_F-dF-dist.png\r\n" - ] - } - ], - "source": [ - "! ls {job.working_directory}/report" - ] - }, - { - "cell_type": "markdown", - "id": "aeea434a", - "metadata": {}, - "source": [ - "# Get LAMMPS potential " - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "a739431f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ConfigFilenameModelNameSpecies
0[pair_style pace\\n, pair_coeff * * /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/output_potential.yace Al Li\\n]ACEpacemaker_job[Al, Li]
\n", - "
" - ], - "text/plain": [ - " Config \\\n", - "0 [pair_style pace\\n, pair_coeff * * /home/users/lysogy36/PycharmProjects/pyiron2021/pyiron_contrib/workshop_data/unpack/pacemaker_job_hdf5/pacemaker_job/output_potential.yace Al Li\\n] \n", - "\n", - " Filename Model Name Species \n", - "0 ACE pacemaker_job [Al, Li] " - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lammps_potential = job.get_lammps_potential()\n", - "lammps_potential" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7d6534da", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python (pyiron2022)", - "language": "python", - "name": "pyiron2022" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}