Active learning machine learning inter-atomic potential (MLIP) training method

Abstract

The invention discloses an active learning machine learning inter-atomic potential (MLIP) training method. The method includes receiving one or more data sets associated with a material. The method also includes actively learning the dynamic trajectory in response to one or more data sets associated with the material. The dynamic trajectory samples the first set of structures and progresses to the second set of structures to create an actively learned MLIP to predict one or more atomic values of the material. The MLIP training method may include biasing the samples with, for example, temperature and / or potential biases.

Description

Technical Field

[0001] The present invention generally relates to an active learning machine learning interatomic potential (MLIP) training method. The MLIP can be a Gaussian process (GP) based MLIP (e.g., FLARE) and / or a graph neural network (GNN) based MLIP (e.g., NequIP or Allegro). The MLIP training method can include biasing the sampling with, for example, temperature and / or potential bias. Background Art

[0002] Ab initio calculations (e.g., density functional theory, also known as DFT) have been used to obtain accurate estimates of atomic-scale material interaction energies. These ab initio calculations are computationally expensive and therefore have a high computational cost. Machine-learned interatomic potentials (MLIPs) can be used to develop short-range models that can infer interaction energies with accuracy approaching that of ab initio calculations while reducing the computational cost by several orders of magnitude. MLIPs have shown promise as a compromise between accuracy and computational efficiency. Summary of the invention

[0003] According to one embodiment, an active machine learning interatomic potential (MLIP) training method is disclosed. The method includes receiving one or more data sets associated with a material. The method also includes actively learning a dynamic trajectory in response to the one or more data sets associated with the material. The dynamic trajectory samples a first set of structures and progresses to a second set of structures to create an actively learned MLIP to predict one or more values ​​(e.g., atomic-level and / or structural-level values) of the material. A non-limiting example of a structural-level value is total energy.

[0004] According to another embodiment, an active machine learning interatomic potential (MLIP) training method is disclosed. The method includes receiving one or more data sets associated with a material. The method also includes actively learning a dynamic trajectory in response to the one or more data sets associated with the material. The dynamic trajectory includes a temperature ramp to create an actively learned MLIP to predict one or more values ​​of the material (e.g., atomic-level and / or structural-level values). A non-limiting example of a structural-level value is total energy.

[0005] According to yet another embodiment, an active machine learning interatomic potential (MLIP) training method is disclosed. The method includes receiving one or more data sets associated with a material. The method also includes actively learning a dynamic trajectory in response to one or more data sets associated with the material. The dynamic trajectory includes biased sampling to create an actively learned MLIP to predict one or more values ​​(e.g., atomic-level and / or structural-level values) of the material. A non-limiting example of a structural-level value is total energy. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] Figure 1Depicted is a workflow for an iterative machine learning interatomic potential (MLIP) training method according to one or more embodiments.

[0007] Figure 2A , 2B and 2C depict a model representing an example of active learning with a reinforced sampling strategy between two fluorocarbon chains.

[0008] Figure 3 is a schematic diagram of the functionality of a block-level directory for an iterative GP-based MLIP training method according to one or more embodiments.

[0009] Figure 4 Depicted is a workflow for an iterative MLIP training method according to one or more embodiments.

[0010] Figure 5 is a schematic diagram of the functionality of a block-level directory for an iterative GNN-based MLIP training method according to one or more embodiments.

[0011] Figure 6 is a schematic diagram of a computing platform that can be used to implement the iterative MLIP training method of one or more embodiments. DETAILED DESCRIPTION

[0012] As required, detailed embodiments of the present invention are disclosed herein; however, it should be understood that the disclosed embodiments are merely examples of the present invention, which may be implemented in various and alternative forms. The drawings are not necessarily to scale; some features may be enlarged or minimized to show details of particular components. Therefore, the specific structural and functional details disclosed herein should not be interpreted as limiting, but merely as a representative basis for teaching those skilled in the art to adopt the present invention in different ways.

[0013] The term "substantially" may be used herein to describe disclosed and / or claimed embodiments. The term "substantially" may modify a value or relative property disclosed or claimed in the present disclosure. In this case, "substantially" may mean that the value or relative property it modifies is within ±0%, 0.1%, 0.5%, 1%, 2%, 3%, 4%, 5%, or 10% of the value or relative property.

[0014] The effectiveness of machine learning interatomic potentials (MLIPs) relies on the interpolation of structures available in the training data used by MLIPs, and the configuration space of the training data depends on the method used to generate the training data. Ab initio molecular dynamics (AIMD) can be used to generate training data for MLIPs. However, AIMD-based procedures are very inefficient because they often contain highly redundant data and poor coverage of available system configurations.

[0015] In recent years, several MLIPs have emerged to improve accuracy and data efficiency. For example, FLARE and Allegro have been developed by the Materials Intelligence Group (MIR) at Harvard University. Other groups have also developed MLIPs based on deep learning, graph neural networks, graph transformers, and other architectures. As another example, NequIP is an open source code for building E(3)-equivariant interatomic potentials. These MLIPs can be trained on a relatively large number of training structures at a high-fidelity computational level to predict interatomic forces or environments. For example, MLIP training can include the following steps: (a) generating a set of structures; (b) using DFT or other high-fidelity methods to calculate atomic values ​​(e.g., total energy, atomic forces, charge distribution, stress, and / or polarization) and / or structural level values; and (c) training the MLIP to correctly predict one or more atomic values ​​and / or structural level values. For example, the total energy can be predicted, and the atomic forces and / or stresses can be calculated by respectively differentiating the atomic positions and / or strains.

[0016] FLARE MLIP drives molecular dynamics (MD) through a Gaussian process (GP)-based MLIP, and training data is generated only when the estimated uncertainty exceeds a given criterion. In the GP form, it is possible to identify the uncertainty of a given prediction based on the difference between the atomic environment in the training data and the atomic environment at the time of inference. In this way, FLARE MLIP learns from data containing new atomic configurations, thus reducing redundant ab initio calculations for those highly overlapping configurations. This training scheme of FLAREMLIP can be referred to as "on-the-fly" (OTF) training. On the other hand, if a set of predetermined snapshots is fed into FLARE instead of being driven by MD, the training is called "offline". The disadvantage of FLARE is that the size of the model grows as more snapshots and / or more elements are included in the model, and the overall accuracy of the trained MLIP is lower than that of alternative methods. In addition, memory consumption and computational efficiency may eventually decrease over time.

[0017] On the other hand, NequIP and Allegro are MLIPs based on graph neural networks (GNNs). NequIP and Allegro have constant model size and inference time as a function of the size of the training data. These types of MLIPs also provide superior accuracy to known methods. However, these methods do not have a computationally efficient and rigorous way to estimate uncertainty. As a result, very large amounts of training data are required to achieve acceptable accuracy and stability.

[0018] When MLIP enters an atomic environment not represented in the training data, it may be forced to extrapolate from its training data. In this extrapolation region, a common result is non-physical behavior (e.g., unrealistic bond breaks, incorrect forces and energies, and / or numerical instabilities). This phenomenon can be referred to as "instabilities" in the model. While in FLARE these extrapolations and instabilities can be identified and corrected using OTF training, OTF training is not an option for NequIP and Allegro, resulting in the requirement that the training data be comprehensive enough to avoid extrapolating in all relevant scenarios.

[0019] The mathematical properties of FLARE and NequIP / Allegro result in a trade-off between the ability to perform uncertainty-based sampling and the performance / accuracy of the final model. To avoid the shortcomings of these different types of MLIPs and combine their advantages, careful planning of training strategies for complex atomic systems is beneficial but challenging. What is desired is a streamlined approach (e.g., a workflow) that (1) automates the process of constructing an efficient and comprehensive training dataset; and (2) trains a stable and accurate MLIP from the dataset.

[0020] In view of the foregoing, in one or more embodiments, an iterative training method (e.g., workflow) for MLIPs for atomic-level simulations is disclosed. The iterative training method can have one or more of the following properties: (1) efficient training data generation for complex atomic systems; (2) parallelized training of multiple substructures and / or hyperparameters on a high-performance computing (HPC) facility; (3) serialized training on incrementally more complex structures; and / or (4) self-consistent iterative training to identify and correct model defects. In one or more embodiments, the iterative training method simplifies the process of building MLIPs for complex systems and / or sampling a wide range of potential energy surfaces for different substructures. The iterative training method can facilitate the development of accurate and efficient MLIPs for computational materials and chemistry research.

[0021] The training method of one or more embodiments may also be applied to other high-fidelity / high-speed pairings (eg, DFT / MD pairings, quantum chemistry / MD pairings, all-atom dynamics / coarse-grained dynamics pairings, etc.).

[0022] Iteratively trained MLIPs can be used by machine learning systems for studying physical phenomena such as, but not limited to, ion transport, chemical reactions, and bulk and surface degradation of materials in material systems (e.g., devices or functional materials). Non-limiting examples of such material systems include fuel cells, surface coatings, batteries, water desalination, and water filtration.

[0023] In one or more embodiments, an iterative training method is disclosed to automate MLIP. In some embodiments, the iterative training method can automate GP-based MLIP (e.g., FLARE) and can be referred to as an iterative GP-based MLIP training method. In other embodiments, the iterative training method can automate GNN-based MLIP (e.g., NequIP and / or Allegro) and can be referred to as an iterative GNN-based MLIP training method. The iterative training method can be implemented using one or more python packages.

[0024] In one embodiment, a method for iteratively training at least one MLIP in a loop is disclosed. Each iteration of the loop may include training multiple (e.g., two or more) different MLIP models in parallel. The method may further include combining different MLIP models trained in parallel to create an iteratively trained MLIP. The iteratively trained MLIP may be a more accurate model than a model without parallel training of multiple different MLIP models. At least one MLIP may be a GP-based MLIP (e.g., FLARE). At least one MLIP may be a GNN-based MLIP (e.g., NequIP or Allegro).

[0025] The method of iteratively training at least one MLIP according to one or more embodiments may include an active learning component. The active learning component may include identifying a predicted confidence and / or a predicted uncertainty, and if the predicted confidence drops below a predicted confidence threshold and / or the predicted uncertainty exceeds a predicted uncertainty threshold, calling a higher accuracy model (e.g., DFT).

[0026] Two or more of the multiple different MLIP models may use different hyperparameters. For example, the first MLIP model(s) may use a first set of hyperparameters, and the second MLIP model(s) may use a second set of hyperparameters that are different from the first set of hyperparameters.

[0027] Two or more of the multiple different MLIP models may use different starting atomic structures and / or different chemical compositions. For example, the first MLIP model(s) may use a first starting atomic structure, and the second MLIP model(s) may use a second starting atomic structure different from the first starting atomic structure. As another example, the first MLIP model(s) may use a first chemical composition, and the second MLIP model(s) may use a second chemical composition different from the first chemical composition. As yet another example, the first MLIP model(s) may use a first starting atomic structure and a first chemical composition, and the second MLIP model(s) may use a second starting atomic structure different from the first starting atomic structure and a second chemical composition different from the first chemical composition.

[0028] The method of iteratively training at least one MLIP may include a combination step, wherein the MLIP model with the lowest error is selected. This type of selection may be modeled after hyperparameter selection.

[0029] The method of iteratively training at least one MLIP may include a combining step including retraining on a larger training set than a training set of any individual MLIP model in the plurality of MLIP models.

[0030] In one or more embodiments, the combining step can account for atomic environment overlap to generate a minimal but descriptive set of atomic structures and forces, thereby allowing a more lightweight model than would be possible using all structures. In another embodiment, the combining step can include an automatic selection criterion based on the energy of each atom in any given atomic structure to exclude non-physical configurations.

[0031] In one or more embodiments, a method of iteratively training at least one MLIP may include enabling a subsequent network to learn from one or more instabilities of a previous network when there are at least two instances of a cycle comprising a machine learning system (e.g., a neural network) having substantially similar parameters or hyperparameters.

[0032] When multiple different MLIP models are not at least close to or at the Pareto front, multiple different MLIP models trained in parallel may be terminated early. The Pareto front can be defined as a trade-off between two or more parameters (e.g., speed and accuracy). A non-limiting list of parameters of interest includes energy accuracy, force accuracy, stress accuracy, polarization accuracy, inference speed of the model, and GPU memory footprint of the model. The Pareto front can refer to a set of optimal solutions in the space of the objective function in a multi-objective optimization problem. The set of optimal solutions can be a set of solutions that are non-dominated to each other but better than the rest of the solutions in the search space. The Pareto space is in principle higher than two dimensions (one dimension for each quantity of interest). The Pareto front can have N-1 dimensions, where N is the number of quantities of interest that make up the entire space.

[0033] In one or more embodiments, in a first iteration of the loop, a machine learning system (eg, a neural network) is used to generate at least one starting structure for an active learning scheme in a second iteration of the loop.

[0034] In one or more embodiments, a first iteration of the loop may include removing data points based on thermodynamic relevance (eg, structures that exceed system-specific limits on formation energy or force magnitude).

[0035] In one or more embodiments, a method of training at least one MLIP using an active learning component of a dynamic trajectory is disclosed. The dynamic trajectory may first sample a near-equilibrium structure and progress (eg, systematically progress) to a structure far from equilibrium.

[0036] A near-equilibrium structure may refer to a system that is substantially close to, but not in, a state of thermodynamic equilibrium (e.g., a state in which all macroscopic properties of the system remain constant over time and there is no net energy flow within the system). A near-equilibrium structure may exhibit only substantially minor fluctuations in its properties and / or substantially insignificant changes in the system compared to no change in the system. A far-from-equilibrium structure may refer to a system that is substantially far from a state of thermodynamic equilibrium. A far-from-equilibrium structure may exhibit substantially large deviations from equilibrium conditions. A far-from-equilibrium structure may involve rapid and complex changes in its properties.

[0037] The dynamic trajectory may include a temperature ramp that progresses from a lower temperature to a higher temperature. The dynamic trajectory may include a bias potential to drive a collective motion of particle positions. The dynamic trajectory may include other forms of biased sampling. The biased sampling may include sampling a subset of structures from a data set of structures of a material, wherein the sampling is performed to prioritize one or more features of the structures and / or data set. The biased sampling may drive specific collective motions within a material.

[0038] The iterative GP-based MLIP training method of one or more embodiments may be implemented separately or together with the iterative GNN-based MLIP training method of one or more embodiments. The iteration of the loop disclosed herein may be referred to as a block. In one or more embodiments, a block may be executed continuously. The multiple parallel trainings disclosed herein may be referred to as a system (e.g., using different chemistry and / or starting structures) or a session (e.g., using different hyperparameters).

[0039] The iterative GP-based MLIP training method of one or more embodiments may include a set of scripts configured to automate loops of GP-based MLIP runs (eg, FLARE runs) according to one or more embodiments disclosed herein.

[0040] The iterative GP-based MLIP training method can use a hierarchical order to manage digital files and directories. The hierarchical order can be (1) project level, (2) block level, (3) system level, and (4) iteration level. The function of each level according to one or more embodiments is disclosed below.

[0041] At the project level, digital files and digital subdirectories may relate to applications associated with a complex system that spans a wide range of chemical elements and material phases. In one or more embodiments, a project may include multiple block-level directories. For example, solvents and / or salts may be combined into a single project.

[0042] At the block level, the digital files and subdirectories may correspond to multiple substructures derived from the application. In one or more embodiments, the substructures may have similar length scales, relatively simple phases, and relatively simple chemical compositions. For example, a block level of solvated salts may include substructures of water, ice, ions, and ions with small solvation shells. The output of each block may include (1) a set of selected data for training, and (2) a single model containing all training data found by active learning loops in one or more systems.

[0043] When a block does not use data or a model from another block, a block can train a model from scratch (e.g., "train on the fly from scratch", also known as OTF-S). A block can start training a model with a pre-trained model output from another block (e.g., "train on the fly from a model", also known as OTF-M). A special type of block can include a single training from a set of known structures and forces from another block. When starting model training from an empty model, this type of block can be referred to as "training offline from scratch" (or OFL-S). When starting training from a pre-trained partial model, this type of block can be referred to as "training offline from a model" (or OFL-M).

[0044] The block-level catalog may include multiple system-level catalogs. Final training of a block may start with a large set of structures for which the atomic environments, energies, forces, and / or stresses are known, where final training then selects a subset of these structures that are sufficiently different to provide a lightweight (e.g., relatively low memory) model. "Different" may be based on the kernel of the system (e.g., atomic environment descriptors).

[0045] At the system level, digital files and subdirectories can correspond to specific substructures (e.g., specific instances of atomic structures) with fixed chemical compositions. The specific substructures can be of fixed chemical compositions. In this example, a single FLARE model can be iteratively OTF trained. A system-level directory may contain many iteration-level directories. A special type of system-level directory may contain only a single training iteration of OTF training data from the same block and / or accumulated from other blocks. This system-level directory may be referred to as "offline".

[0046] At the iteration level, digital files and subdirectories can be associated with a single FLARE execution, which is an OTF training restarted from a previous FLARE execution. Iteration level directories can output a single MD trajectory ready to restart and multiple selected snapshots calculated by DFT.

[0047] Figure 1 Describe the workflow 100 of the iterative GP-based MLIP training method (e.g., FLARE) according to one or more embodiments. Structure 102 (e.g., multiple substructures as components of a complex system) is input into block 104. One or more substructures can be distributed to a system-level directory as a starting point for OTF training. The system-level directory can include systems 106A, 106B, and 106N. After several iterations of OTF training in each system, data can be collected and shuffled for offline training (e.g., 108). Offline training can eventually produce a model that learns from data from all substructures and saves used and unused data to generate such a model. Then, the model can be used as an initial model for another block (e.g., block 110), which can have substructures of different groups. Used data from block 110 can be combined with used data from other blocks (e.g., block 104), which can generate a model of a chemical subspace containing two or more other blocks.

[0048] The iterative GP-based MLIP training method of one or more embodiments can effectively generate training data for complex atomic systems. The training data can be implemented at the system and iteration levels. A scheduler can be created in one or more systems. Figure 1As shown, scheduler 112 is associated with blocks 104 and 110, and scheduler 114 is associated with blocks 116 and 120. The scheduler can determine a strategy for MD to drive the substructure toward the undersampled space. The strategy can be versatile and flexible, which can include a ramp of the temperature of the substructure or a forced enhanced sampling method such as collective variable dynamics. The strategy can be implemented with a computer package (e.g., PLUMED).

[0049] Figure 2A , 2B 2C depict models 200, 202, and 204, respectively, which represent examples of active learning with an enhanced sampling strategy between two fluorocarbon chains. The iterative GP-based MLIP training method actively learns a wide range of configurations and includes them in the dataset.

[0050] Figure 3 306C, which outputs results 308 (e.g., data, output by the group of systems <e>, plots, and model estimated per-atom energies). Results 308 may be input into offline training 310. The output of offline training 310 may be input into results 308 for model and / or data use.

[0051] The iterative GP-based MLIP training method of one or more embodiments can parallelize the training of multiple substructures on a high performance computing (HPC) facility at both the project level and the block level. Multiple projects can be managed by submitting OTF training jobs for each system in parallel on the HPC. For example, a set of substructures of the water and NaCl structure 402 of the workflow 400 in block 404 can be (1) a volume of liquid H 2 O, (2) Bulk crystal H 2 O, (3) with solvated Na + and Cl - Volume of liquid H 2 O, and (4) bulk crystalline NaCl, where all substructures can have similar box sizes. Structure 402 can be created by a user of a GP-based MLIP training method. Substructures can be assigned to system-level directories, and active learning cycles can be performed in each system folder. Jobs can be submitted to the HPC facility for each system at a time, where each system can have a different strategy dynamic trajectory, such as temperature ramping or enhanced sampling.

[0052] After OTF / offline training in a block, the trained offline model can be inherited by a new block starting with a more complex set of substructures. For example, after several iterations of the active learning loop in block 404, the offline model can be trained with all the training data found by the OTF training loop in each system. Block 406 can be created starting with a set of substructures, such as (1) the previous volume of liquid H in block "A" 2 2×2×2 supercell of O, (2) liquid H 2 O-crystalline NaCl interface, (3) with solvated Na + and Cl - Liquid H 2 A 2×2×2 supercell of O. The trained offline model in block 404 may be inherited by block 406 as a starting point for an active learning loop in block 406 .

[0053] The iterative GNN-based MLIP training method of one or more embodiments may include a set of scripts that use a GNN-based MLIP (e.g., NequIP or Allegro) to train a machine learning potential and identify hyperparameters, including determining and fixing instabilities in a given potential.

[0054] The iterative GNN-based MLIP training method can use a hierarchical order to manage digital files and directories. The hierarchical order can be (1) project level, (2) block level, (3) session level, and (4) iteration level. The function of each level according to one or more embodiments is disclosed below.

[0055] At the project level, digital files and digital sub-directories may relate to applications associated with complex systems spanning a wide range of chemical elements and material phases. In one or more embodiments, a project may include multiple block-level directories.

[0056] At the block level, the digital files and subdirectories can correspond to one or more GNN-based MLIP training models (e.g., multiple NequIP and Allegro models). A block containing multiple models can be a block for hyperparameter screening. A block containing a single model can be a block for longer training and MD runs. Each block can contain multiple session-level directories (e.g., block 116 receives input from data set 118 from block 110). Workflow 100 also includes block 120, which receives data output from block 116.

[0057] At the session level, digital files and digital subdirectories can correspond to NequIP / Allegro models with a fixed set of hyperparameters. A single NequIP / Allegro model can be trained iteratively and terminated if it performs poorly compared to other sessions.

[0058] At the iteration level, a number of files and a number of subdirectories may be associated with a single NequIP / Allegro execution, which is training restarted from a previous NequIP / Allegro execution. An iteration level directory may contain a single training history and a temporary model ready to be restarted.

[0059] The iterative GNN-based MLIP training method of one or more embodiments can provide parallel training for multiple hyperparameter sets on one or more HPC facilities. The iterative GNN-based MLIP training method of one or more embodiments can provide a flexible screening scheduler that accepts submissions of arrays of jobs in parallel, each of which trains candidate models using a unique set of hyperparameters. Hyperparameter screening (e.g., as performed in block 408 of workflow 400) can be implemented by an iterative training loop, where if the performance of some candidate models is not Pareto efficient, these candidate models are discarded, as disclosed herein. Performance can be defined by a set of user-defined metrics. After several iterations of training, a model can be selected for longer training, where all candidate models are Pareto efficient. A non-limiting list of metrics of interest can include the energy accuracy, force accuracy, stress accuracy, inference speed, and graphics processing unit (GPU) memory occupancy of the model.

[0060] The iterative GNN-based MLIP training method of one or more embodiments can provide self-consistent iterative training (e.g., as performed in blocks 410 and / or 412 of workflow 400) that automatically adjusts model defects. Through the iterative GNN-based MLIP training method, the trained model can be sent to an array for stability testing. The iterative GNN-based MLIP training method can provide a flexible stability test scheduler that screens all or some MD parameters (e.g., temperature, time step, etc.). The test may result in non-physical behavior, resulting in atomic configurations that are not fully represented in the training set. Then, a subset of the test trajectory can be selected and sent to high-accuracy calculations, such as DFT. These snapshots can be included in the training data set for the next training iteration, perhaps as a starting substructure of a block of the iterative GP-based MLIP training method, or as a single-point snapshot of an iterative GNN-based MLIP training session. This process can define a self-consistent iterative training loop. Through this loop, the model can self-identify its defects and correct them along the iteration. When the hyperparameters remain unchanged, adding these data points to the training set can address the instability of the potential of the machine learning system.

[0061] Figure 5 5 is a functional schematic diagram of a block 500 of an iterative GNN-based MLIP training method according to one or more embodiments. Block 500 utilizes configuration files 502 (e.g., ml.yaml, model.yaml, screen.yaml, and stability.yaml). Data files 504 (e.g., Data1.extxyz, Data2.extxyz, Data3.extxyz, and Data4.extxyz) are input to session_0 506A, session_1 506B, and session_2 506C, which produce results 508.

[0062] The iterative MLIP training method of one or more embodiments is implemented using a computing platform such as Figure 6 The computing platform 600 shown. The iterative MLIP training method can be implemented as part of a computing software suite. The computing platform 600 may include a memory 602, a processor 604, and a non-volatile storage device 606. The processor 604 may include one or more devices selected from a high-performance computing (HPC) facility, including a high-performance core, a microprocessor, a microcontroller, a digital signal processor, a microcomputer, a central processing unit, a field programmable gate array, a programmable logic device, a state machine, a logic circuit, an analog circuit, a digital circuit, or any other device that manipulates a signal (analog or digital) based on computer executable instructions residing in the memory 602. The HPC facility may include advanced computing hardware and software that is configured to perform computationally intensive tasks at much higher speeds than a typical desktop or server computer. The HPC facility may provide up to one (1) million random read input / output operations per second (IOPS).

[0063] The memory 602 may include a single memory device or multiple memory devices, including but not limited to random access memory (RAM), volatile memory, non-volatile memory, static random access memory (SRAM), dynamic random access memory (DRAM), flash memory, cache memory, or any other device capable of storing information. The non-volatile storage 606 may include one or more persistent data storage devices, such as a hard drive, an optical drive, a tape drive, a non-volatile solid-state device, a cloud storage device, or any other device capable of persistently storing information.

[0064] Processor 604 may be configured to read into memory 602 and execute computer executable instructions residing in software modules 608 and 610 of non-volatile storage device 606 and embodying the iterative MLIP training method of one or more embodiments. Software modules 608 and 610 may include operating systems and applications. Software modules 608 and 610 may be compiled or interpreted from computer programs created using a variety of programming languages ​​and / or techniques, including but not limited to, and alone or in combination, Java, C, C++, C#, Objective C, Fortran, Pascal, JavaScript, Python, Perl, and PL / SQL.

[0065] When executed by processor 604, the computer executable instructions of software modules 608 and 610 may cause computing platform 600 to implement one or more iterative MLIP training methods of one or more embodiments disclosed herein. Non-volatile storage device 606 may also include data 612 and 614 that support the functions, features, and processes of one or more embodiments described herein.

[0066] The program code embodying the algorithms and / or methods described herein can be distributed as program products in various forms, either individually or collectively. Program code can be distributed using a computer-readable storage medium having computer-readable program instructions thereon for causing a processor to perform aspects of one or more embodiments. Essentially non-temporary computer-readable storage media may include volatile and non-volatile and removable and non-removable tangible media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer-readable storage media may also include RAM, ROM, erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other solid-state memory technology, portable compact disk read-only memory (CD-ROM) or other optical storage devices, cassettes, tapes, magnetic disk storage devices or other magnetic storage devices, or any other medium that can be used to store the required information and can be read by a computer. Computer-readable program instructions can be downloaded from a computer-readable storage medium to a computer, another type of programmable data processing device, or another device, or downloaded to an external computer or external storage device over a network.

[0067] Computer-readable program instructions stored in a computer-readable medium can be used to instruct a computer, other types of programmable data processing devices, or other devices to function in a particular manner so that the instructions stored in the computer-readable medium produce an article of manufacture including instructions for implementing the functions, actions, and / or operations specified in the flowchart or diagram. In certain alternative embodiments, the functions, actions, and / or operations specified in the flowchart and diagram can be reordered, processed serially, and / or processed concurrently, according to one or more embodiments. In addition, any flowchart and / or diagram may include more or fewer nodes or blocks than those shown according to one or more embodiments.

[0068] The following applications are related to this application: U.S. patent application serial number 18 / 377,520 (RBPA0462PUS) filed on October 6, 2023, the entire contents of which are incorporated herein by reference.

[0069] Although the entirety of the present invention has been illustrated by the description of various embodiments, and although these embodiments have been described in considerable detail, the applicant does not intend that the scope of the appended claims be constrained or in any way limited to such details. Additional advantages and modifications will be apparent to those skilled in the art. Therefore, the present invention in its broader aspects is not limited to the specific details, representative devices and methods, and illustrative examples shown and described. Therefore, these details may be deviated from without departing from the spirit or scope of the general concept of the present invention.< / e>

Claims

1. An active learning machine learning interatomic potential (MLIP) training method, comprising: receiving one or more data sets associated with the material; as well as Responsive to one or more data sets associated with a material, a dynamic trajectory is actively learned that samples a first set of structures and progresses to a second set of structures to create an actively learned MLIP to predict one or more values ​​of the material.

2. The active learning MLIP training method of claim 1 , further comprising predicting one or more values ​​of a material using the active learning MLIP.

3. The active learning MLIP training method of claim 1, wherein the one or more atomic values ​​include total energy, atomic force, atomic stress, atomic charge and / or polarization.

4. The active learning MLIP training method according to claim 1, wherein the first group of structures are near-equilibrium structures.

5. The active learning MLIP training method according to claim 4, wherein the near-equilibrium structure is substantially close to but not in a thermodynamic equilibrium state.

6. The active learning MLIP training method according to claim 4, wherein the second set of samples is far from the equilibrium structure. 7 . The active learning MLIP training method according to claim 6 , wherein the far-from-equilibrium structure is substantially far from a thermodynamic equilibrium state.

8. The active learning MLIP training method according to claim 1, wherein the active learning MLIP is a Gaussian process (GP) based MLIP.

9. The active learning MLIP training method according to claim 1, wherein the active learning MLIP is a deep learning-based MLIP.

10. An active learning machine learning interatomic potential (MLIP) training method, comprising: receiving one or more data sets associated with the material; as well as In response to one or more data sets associated with a material, a dynamic trajectory is actively learned, the dynamic trajectory including a temperature ramp to create an actively learned MLIP to predict one or more atomic values ​​of the material.

11. The active learning MLIP training method of claim 10, further comprising predicting one or more atomic values ​​of a material using the actively learned MLIP.

12. The active learning MLIP training method according to claim 10, wherein: The temperature ramp starts at a lower temperature and progresses to a higher temperature.

13. The active learning MLIP training method according to claim 12, wherein the lower temperature is lower than the higher temperature.

14. The active learning MLIP training method according to claim 10, wherein the active learning MLIP is a Gaussian process (GP) based MLIP.

15. The active learning MLIP training method according to claim 10, wherein the active learning MLIP is a deep learning-based MLIP.

16. An active learning machine learning interatomic potential (MLIP) training method, comprising: receiving one or more data sets associated with the material; as well as In response to one or more data sets associated with a material, a dynamic trajectory is actively learned, the dynamic trajectory including biased sampling to create an actively learned MLIP to predict one or more atomic values ​​of the material.

17. The active learning MLIP training method according to claim 16, wherein: The biased sampling includes a subset of the material's structure that prioritizes one or more characteristics of one or more data sets associated with the material.

18. The active learning MLIP training method of claim 16, wherein the bias sampling drives a collective variable of the material.

19. The active learning MLIP training method according to claim 16, wherein the bias sample is a bias potential.

20. The active learning MLIP training method of claim 19, wherein the bias potential drives a collective variable of the material.

Images