From 58f2e4b3d9b71bc6446ed525bc3595b57b91219c Mon Sep 17 00:00:00 2001 From: Yani Guan Date: Wed, 13 Nov 2024 17:13:34 -0800 Subject: [PATCH 1/2] add dflow, deepflame two versions, deeptb, unimol update openlam-q3 --- source/_posts/OpenLAM-2024Q1.md | 2 +- source/_posts/OpenLAM-2024Q3.md | 2 +- source/_posts/deepflame.md | 90 +++++++++++++++++++++++ source/_posts/deepflame_v1d4.md | 123 ++++++++++++++++++++++++++++++++ source/_posts/deeptb.md | 56 +++++++++++++++ source/_posts/dflow.md | 64 +++++++++++++++++ source/_posts/unimol.md | 46 ++++++++++++ 7 files changed, 381 insertions(+), 2 deletions(-) create mode 100644 source/_posts/deepflame.md create mode 100644 source/_posts/deepflame_v1d4.md create mode 100644 source/_posts/deeptb.md create mode 100644 source/_posts/dflow.md create mode 100644 source/_posts/unimol.md diff --git a/source/_posts/OpenLAM-2024Q1.md b/source/_posts/OpenLAM-2024Q1.md index 79d8e81e..95aba600 100644 --- a/source/_posts/OpenLAM-2024Q1.md +++ b/source/_posts/OpenLAM-2024Q1.md @@ -1,5 +1,5 @@ --- -title: "OpenLAM | 2024 Q1 Report Infrastructure Upgrade and Release of Pre-trained Models Compatible with DeePMD-kit v3" +title: "2024 Q1 OpenLAM Report | Infrastructure Upgrade and Release of Pre-trained Models Compatible with DeePMD-kit v3" date: 2024-05-11 categories: - OpenLAM diff --git a/source/_posts/OpenLAM-2024Q3.md b/source/_posts/OpenLAM-2024Q3.md index fe69a6a1..e02ca12c 100644 --- a/source/_posts/OpenLAM-2024Q3.md +++ b/source/_posts/OpenLAM-2024Q3.md @@ -67,7 +67,7 @@ Table 3. | Python inference speed (s/100 times) | **3.7** | 6.3 | **2. Alloy Domain Model:** - - A property-driven fine-tuning workflow has been developed for large models, supporting fine-tuning across multiple properties to create customized potential models for specific applications. The corresponding Bohrium Notebook, *Finetune Alloy Property using APEX + DPGen2*, is available. See DPA-1&2 alloy large model details at: [Alloy Multi-task Model](https://www.aissquare.com/models/detail?pageType=models&name=DPA-1%262-53-alloy-multitask-400w&id=280). + - A property-driven fine-tuning workflow has been developed for large models, supporting fine-tuning across multiple properties to create customized potential models for specific applications. The corresponding Bohrium Notebook, *Finetune Alloy Property using APEX + DPGen2*, is available. See DPA-1&2 alloy large model details at: [Alloy Multi-task Model](https://www.aissquare.com/models/detail?pageType=models&name=DPA-1%25262-53-alloy-multitask-400w%255BEN%255D&id=283). ## Community **OpenLAM Crystal Structure Competition:** diff --git a/source/_posts/deepflame.md b/source/_posts/deepflame.md new file mode 100644 index 00000000..d649a377 --- /dev/null +++ b/source/_posts/deepflame.md @@ -0,0 +1,90 @@ +--- +title: "DeepFlame: Co-Building the Computational Platform for Combustion Reactive Fluids in the Era of AI for Science" +date: 2022-06-13 +categories: +- DeepFlame +--- + +Combustion, particularly in multiphase and turbulent scenarios, involves the intricate integration of a range of complex, multiscale problems, and has long been a challenging area in large-scale scientific computing. Recently, the DeepModeling open-source community initiated a new research paradigm that combines "machine learning, physical modeling, and high-performance computing," offering an opportunity to pursue systematic solutions in this field. + +The DeepFlame project, built on open-source platforms such as OpenFOAM, Cantera, and Torch, leverages next-generation computational infrastructure, including heterogeneous parallel computing and AI accelerators. It aims to develop a numerical simulation program for combustion reactive flows that is high-precision, efficient, easy to use, and broadly applicable. The project seeks to address issues like the monopolization of proprietary codes, the concentration of computational resources, and the stagnation of legacy codes. Additionally, it aims to harness the power of the open-source community to create a shared platform for code, computational resources, and case libraries for combustion simulation users, with the goal of overcoming challenges like the lack of available codes for researchers and the difficulty of reproducing results from academic papers. + + + +## Why DeepFlame +Computational Fluid Dynamics (CFD), based on the numerical solution of macroscopic continuous medium Navier-Stokes equations, has already played an irreplaceable role in fields such as aerospace and meteorological forecasting. The numerical solution of continuous partial differential equations by computers requires numerical discretization. The finite volume method, which is based on spatial grid discretization, is one of the most widely applied methods and has been implemented and industrialized in various foreign commercial CFD software, such as ANSYS Fluent, StarCCM+, etc. + +On the other hand, the calculation of chemical reaction kinetics at the macroscopic level typically uses the Arrhenius formula to solve elementary reaction rates. Combustion systems usually consist of hundreds to thousands of components and even more elementary reactions, requiring the solution of a large set of ordinary differential equations over time. Similar commercial software like ChemkinPro, CosiLab, etc., have been developed abroad to solve such systems. + +However, fluid dynamics calculations involving combustion reactions require the coupling of the above two aspects, presenting even greater challenges. Despite the various functionalities developed and tested by commercial software, current computational accuracy and efficiency are still relatively low, making it difficult to meet the demands of industrial applications. From a scientific research perspective, there is an urgent need for a widely accessible open-source code to support the development of scientific computing in combustion reactive fluid dynamics. + +In recent years, as computer technology has increasingly penetrated scientific research, the open sourcing and collaborative development of software code have greatly propelled the development of various industries. This is becoming a common understanding. Among the numerous open-source programs, OpenFOAM and Cantera have emerged as leaders in the fields of CFD and reaction kinetics calculation, respectively, with the most widespread user and developer communities worldwide. Recently, research teams domestically and internationally have attempted to combine the two, but have not yet formed an effective open-source collaborative development mechanism. The research has been confined within research groups, lacking an external ecosystem, and has not become widespread. In the realm of deep learning, the use of open-source libraries like Torch and TensorFlow remains relatively independent, and integration with combustion CFD has yet to be achieved. The highly serial workflows also suffer from inefficiencies, poor portability, and high error rates. + +Targeting these issues, the initial intention of the DeepFlame project is to build upon the open-source collaborative culture already established within the DeepModeling community and to draw on the development experiences of other projects within the community. The goal is to create an open-source platform serving the combustion reactive fluid dynamics scientific computing community, attracting more developers to join our ranks, and in turn benefiting a broader user base, ultimately promoting the application of combustion computing in industrial scenarios. + +## The pain points addressed by DeepFlame +First and foremost, it is important to clarify that DeepFlame is not intended to be a general-purpose CFD software. Our focus is solely on tackling the "tough nut" of combustion reactive fluid dynamics. + +With this in mind, the first task is to "slim down" OpenFOAM, which consists of millions of lines of code, by minimizing dependencies on unrelated function libraries while maintaining the integrity of the source code structure (to facilitate future version migrations). This might sound trivial, but anyone familiar with the "nested" structure of OpenFOAM knows that this is far from easy. + +Another pain point we aim to address is how to completely replace the cumbersome OpenFOAM combustion reaction thermophysical library and the extensive strings and parameters related to reaction mechanisms with Cantera, making the process more efficient (see the comparison of the code and logic framework before and after optimization in the image below). + +Regarding the integration of AI capabilities, we have also completed a demonstrative validation. For the chemical reaction rate stiffness issue that limits computational speed, DeepFlame can either call the SUNDIALS CVODE solver integrated in Cantera or support neural network surrogate models in native pyTorch format (refer to [4] for the related algorithms). + +Although DeepFlame's current functionality is still somewhat limited, it has already achieved initial success in creating an efficient, portable, and cross-platform coupling of OpenFOAM, Cantera, and Torch. This lays the foundation for the subsequent integration and advancement of physical modeling, high-performance computing, and machine learning. + +
+ +## What can DeepFlame Do? +Based on the above code framework and thermophysical chemistry library, DeepFlame currently offers the following features: + +- Four core solvers: df0DFoam, dfLowMachFoam, dfHighSpeedFoam, and dfSprayFoam. + +- Each solver comes with corresponding case examples and accompanying Allrun and Allclean scripts provided in the examples directory. + +- The calculable systems include: strong turbulent flames in open/confined spaces, complex reaction kinetics laminar flames, spray/particle combustion, supersonic combustion, deflagration-to-detonation transition, continuous rotating detonation waves, and more. + +- Ability to read in chemical reaction mechanisms of any size (supporting cti, xml, yaml formats). + +- Integration with Cantera’s native detailed transport models such as UnityLewis, Mix, and Multi. + +- Two chemical reaction rate solvers: cvode and torch. + +- Adaptation for domestic ARM heterogeneous chips (Kunpeng, Phytium). + +
+ + +## What is DeepFlame going to accomplish? + +### Physical models + AI + +When we talk about combustion reactive fluid dynamics within the continuum, the main physical modeling subjects can be categorized into: + +1. Unresolved scale turbulence models (Reynolds-averaged or subgrid-scale stress) + +2. Chemical reaction kinetics models (including detailed mechanisms, mechanism simplification, ODE integration) + +3. Unresolved scale turbulence and chemical reaction interaction models (Reynolds-averaged or subgrid-scale reaction rates) + +Our current work focuses on Model 2. Therefore, DeepFlame is currently capable of full-scale resolved simulations. For detailed mechanisms within Model 2, we plan to collaborate with the first-principles molecular dynamics simulation project in the DeepModeling community to obtain more optimal reaction pathways and rate constants. For Models 1 and 3, challenges remain, particularly in terms of model generalization due to the unclear upper limits of training data dimensions, especially considering the effects of spatial scale and boundary conditions. Moreover, due to OpenFOAM's second-order accuracy in both time and space, we are developing higher-order accuracy programs to generate training data for small-scale effects. Beyond ideal gas, we also need to explore real gas effects in supercritical states and the atomization process of continuous phase liquids within the DeepFlame framework. + +### High-performance calculations + +When you log into any national supercomputing system worldwide and enter commands like qstat or squeue to display the task list, there's a high probability that you'll see names like VSAP, LAMMPS, and various CFD codes on the screen. CFD related to combustion may account for more than half of the computational power demand in large-scale scientific computing. Currently, DeepFlame's parallel framework is derived from native OpenFOAM, whose parallel acceleration capabilities are not particularly outstanding and urgently need improvement. Additionally, moving chemical reaction rate calculations and AI inference to GPUs or other accelerators would yield better results. These are the directions for our future work. Furthermore, in the context of Exascale Computing, DeepFlame will need to be adapted and optimized for the new generation of domestic heterogeneous supercomputing platforms to support larger-scale and faster computations. + +## How to Join the Development of DeepFlame +If you are interested in DeepFlame's combustion CFD and machine learning code development or high-performance optimization, we recommend reaching out to us directly via GitHub. Your ideas will be highly valued! As the project is still in a relatively early stage, we will soon begin organizing communication groups and establishing more channels based on the emerging needs. + +If you wish to use DeepFlame for your research, please follow DeepFlame on GitHub and subscribe to this public account to stay updated on relevant developments. Additionally, you are welcome to join the "DeepFlame User Group" to discuss and share tips on using DeepFlame! + +## DeepFlame Team and Timelines +DeepFlame was initiated and led by Dr. Zhi Chen from Peking University, with AI modeling support provided by Tianhan Zhang from Beihang University and Zhiqin Xu from Shanghai Jiao Tong University. The project is supported by the research collaboration platform of the Beijing Academy of Artificial Intelligence (AISI) and receives code hosting and related technical support from the DeepModeling community. + +- On January 16, 2022, during a special invited lecture on turbulent combustion at the Academic Annual Conference on Combustion of the Chinese Society of Engineering Thermophysics, Dr. Zhi Chen made an urgent appeal to his colleagues in the combustion community: "Without a widely accessible open-source computational platform, foundational research in turbulent combustion simulation will struggle to achieve further effective development." This marked a significant commitment. +- By the end of February 2022, the team was initially formed, and the DeepFlame project was officially launched. +- By mid-March 2022, the team had achieved the coupling of OpenFOAM and Cantera based on a minimal thermophysical library. +- By the end of April 2022, the development of the gas-phase solvers df0DFoam, dfLowMachFoam, and dfHighSpeedFoam was completed. +- By the end of May 2022, the development of the spray combustion solver dfSprayFoam, based on the Lagrangian point source method, was completed, along with the integration of the Torch API and adaptation for domestic ARM architecture chips (Kunpeng, Phytium). +- On June 13, 2022, the DeepFlame code repository was officially hosted by the DeepModeling community, and version 0.1.0 was released as open-source. + diff --git a/source/_posts/deepflame_v1d4.md b/source/_posts/deepflame_v1d4.md new file mode 100644 index 00000000..91748d9e --- /dev/null +++ b/source/_posts/deepflame_v1d4.md @@ -0,0 +1,123 @@ +--- +title: DeepFlame 1.4 Released, Introducing Full-Speed Range Multiphase Reactive Flow Solver" +date: 2024-08-23 +categories: +- DeepFlame +--- + +DeepFlame is an open-source combustion fluid dynamics platform developed for the AI for Science era [1-3], aimed at overcoming the longstanding challenges of applying traditional Computational Fluid Dynamics (CFD) in the field of combustion. Since its release, DeepFlame has garnered significant interest and attention from both academia and industry, attracting a group of outstanding developers and users. This ongoing support has provided continuous momentum for DeepFlame's development and has been a crucial driving force in its application to real-world scenarios. + +In recent years, research on aerosol or spray detonation propulsion using liquid fuels has been experiencing a resurgence, and supersonic combustion, such as detonation combustion in gas-liquid two-phase systems, has been gaining increasing attention. The DeepFlame team has captured these trending topics and, based on the OpenFOAM open-source library, coupled the Euler-Lagrange model into the high-speed flow solver dfHighSpeedFoam and the low-speed flow solver dfLowMachFoam. This enables the solvers to simulate two-phase reactive flows, thereby expanding the application scenarios of DeepFlame. + + + +## Version Update Overview +- In the new version, the Lagrangian source term has been coupled into the high-speed reactive flow solver dfHighSpeedFoam, enabling it to calculate two-phase reactive flows. Similarly, the Lagrangian source term has also been coupled into the low-speed reactive flow solver dfLowMachFoam, replacing dfSprayFoam for low-speed two-phase reactive flow calculations. +- The Lagrangian model has been fine-tuned by adjusting the order of particle temperature and velocity updates, and the liquidEvaporationSpalding evaporation model has been added. +- For the high-speed reactive flow solver dfHighSpeedFoam, a new convection scheme library has been added. +- Additionally, tools for converting Lagrangian particle position coordinates have been added to the submodels. + +## New Feature: High-Speed Reactive Flow Solver Coupled with Two-Phase Calculation Module +The new version, based on the OpenFOAM open-source library, couples the Euler-Lagrange model into the high-speed flow solver dfHighSpeedFoam to simulate gas-liquid two-phase reactive flows. Building on this, the new version fine-tunes the Lagrangian model and two-phase submodels, enabling the dfHighSpeedFoam solver to more accurately capture key parameters and characteristics of gas-liquid interactions, such as changes in droplet diameter and velocity. Additionally, the new version introduces examples of shock wave propagation through water mist and two-phase detonation, thereby validating the high-speed flow solver's ability to accurately capture flow instabilities and the coupling of shock waves with chemical reactions. + +Figure 1 shows a schematic of the ethylene/air + water mist two-dimensional two-phase detonation computational domain. The initial gas phase temperature and pressure are 300 K and 101,325 Pa, respectively, with an equivalence ratio of 1. In the two-phase region, the water droplet diameter is 11 μm, and the initial temperature is 300 K, with specific settings referenced from [4]. The computation begins with ignition at three high-temperature, high-pressure points. + + +
+ + + + +As the detonation wave progresses, relatively regular and distinct cellular structures can be observed, and the different physical fields effectively demonstrate the influence of water droplets on the cell size and the formation of the detonation wave. The evolution of peak pressure shown in Figure 2 indicates a slight increase in cell size within the two-phase region. From the temperature field depicted in Figure 4, it can be observed that the temperature behind the wave front is lower due to the evaporation of the droplets. + + +
+ + + + +## New Feature: Low-Speed Reactive Flow Solver Coupled with Two-Phase Calculation Module +Similar to dfHighSpeedFoam, the new version also integrates the Euler-Lagrange model into the low-speed flow solver dfLowMachFoam to simulate gas-liquid two-phase reactive flows, functionally replacing the previous spray solver dfSprayFoam. Figure 6 presents a simulation study of kerosene combustion around two blunt bodies using the new version of dfLowMachFoam. The computational domain for this case is a rectangular combustion chamber measuring 0.8m × 0.2m × 0.04m. Two blunt bodies, each with a length of L = 0.04m and a height of H = 0.032m, are fixed at both ends on the chamber walls, symmetric about the central plane, with a distance of 0.08m between the central planes of the two blunt bodies. In this case, the airflow rate is 0.6kg/s, and the fuel-air ratio is 0.055. It can be observed that dfLowMachFoam accurately captures the high-frequency oscillation phenomena within the combustion field, with the oscillation modes closely matching experimental observations. + + +
+ +
+ +
+ +
+ + +## Additional Features and Optimizations +### New Convection Schemes Added to dfHighSpeedFoam + +In version 1.4, a new convection scheme library has been added to the high-speed reactive flow solver dfHighSpeedFoam, referencing detonationFoam [5]. This library includes KT, KNP, HLLC, and HLLCP schemes, with the addition of AUSMDV [6]. The HLLC scheme, applied in this updated version to the ethylene/water droplet suspension in air two-phase detonation, has shown promising performance. + +### Neural Network Training and Inference Compatibility with Baidu PaddlePaddle Framework + +In version 1.4, the neural network inference and training module, which replaces the chemical source term ODE solver in DeepFlame, has been successfully made compatible with the Baidu PaddlePaddle framework. This allows users to more conveniently perform deep learning tasks within the PaddlePaddle environment. The code repository now includes example cases and documentation using the PaddlePaddle framework to help users quickly get started and fully leverage PaddlePaddle's strengths. + +## DeepFlame Quick Access Link +The GitHub repository for DeepFlame within the DeepModeling community can be accessed at: + +https://github.com/deepmodeling/deepflame-dev + +Release tag for DeepFlame version 1.4: + +https://github.com/deepmodeling/deepflame-dev/releases/tag/v1.4 + +Documentation (including installation instructions, input/output parameter descriptions, feature overview, case study introductions, developer notes, etc.): + +https://deepflame.deepmodeling.com/en/latest/ + + +## Feature Updates and Bug Fixes List +### v1.4.0 + +- Fine-tuned the Lagrangian model by adjusting the update order of particle temperature and velocity, and added the liquidEvaporationSpalding evaporation model. by @pkuLmq in #504 + +- Integrated Lagrangian source terms into the low-speed reactive flow solver dfLowMachFoam. by @pkuLmq in #506 + +- Coupled Lagrangian source terms into the high-speed reactive flow solver dfHighSpeedFoam, enabling it to simulate high-speed two-phase reactive flows. by @pkuLmq in #510 + +- Added a new convection scheme library to the high-speed reactive flow solver dfHighSpeedFoam (adopted from detonationFoam) with minor adjustments. by @pkuLmq in #510 + +- Added tools for converting Lagrangian particle position coordinates in submodels via lagrangianExtraFunctionObjects (adopted from lagrangianExtraFunctionObjects). by @pkuLmq in #511 + +- Added the AUSMDV scheme to the convection scheme library. by @risinyoung in #512 + +- Made the chemical source term neural network inference compatible with Baidu PaddlePaddle framework. by @BiteBytePKU in #500 + +### v1.4.0 + +- Added new example cases using dfHighSpeedFoam, including a 1D single droplet motion case, a 1D heptane two-phase detonation, a 1D hydrogen/air + water mist two-phase detonation, and a 2D ethylene/air + water mist two-phase detonation. by @pkuLmq in #510 + +- Added a 2D aachenBomb case to the test examples. by @pkuLmq in #509 + +- Modified example cases to incorporate the addition of Lagrangian source terms in the two solvers. by @pkuLmq in #510 and #506 + +- Added a new example case demonstrating the use of Baidu PaddlePaddle framework for neural network inference of chemical source terms. by @BiteBytePKU in #500 + + + +Reference: + +[1] Mao R, Lin M, Zhang Y, et al. DeepFlame: A deep learning empowered open-source platform for reacting flow simulations. Computer Physics Communications, 291: 108842. (2023) + +[2] Mao R, Zhang M, Wang Y, Li H, et al. An integrated framework for accelerating reactive flow simulation using GPU and machine learning models. Proceedings of the Combustion Institute, 40(1-4), 105512. (2024) + +[3] Zhang M, Mao R, Li H, An Z, Chen ZX. Graphics processing unit/artificial neural network-accelerated large-eddy simulation of swirling premixed flames. Physics of Fluids, 36(5). (2024) + +[4] Huang Z, Zhao M, Xu Y, Li G, Zhang H. Eulerian-Lagrangian modelling of detonative combustion in two-phase gas-droplet mixtures with OpenFOAM: Validations and verifications. Fuel, 286, 119402. (2021) + +[5] Sun J, Wang Y, Tian B, Chen Z. detonationFoam: An open-source solver for simulation of gaseous detonation based on OpenFOAM. Computer Physics Communications, 292: 108859. (2023). + +[6] Wada Y, Liou M-S. A flux splitting scheme with high-resolution and robustness for discontinuities. 32nd Aerospace Sciences Meeting and Exhibit. (1994). + + + + + + + diff --git a/source/_posts/deeptb.md b/source/_posts/deeptb.md new file mode 100644 index 00000000..d3656734 --- /dev/null +++ b/source/_posts/deeptb.md @@ -0,0 +1,56 @@ +--- +title: "DeePTB | It supports strictly localized equivariant representation LCAO-quantum operators" +date: 2024-08-15 +categories: +- DeePTB +--- + +In 2023, the AI for Science Institute, Beijing team introduced the v1 version of the DeePTB method, which was published on arXiv and joined the DeepModeling community. After nearly a year of rigorous peer review, it was officially published on August 8, 2024, in the international academic journal Nature Communications with the title "Deep learning tight-binding approach for large-scale electronic simulations at finite temperatures with ab initio accuracy" [1], DOI: 10.1038/s41467-024-51006-4. + +The v1 version of DeePTB focuses on developing a deep learning-based method for constructing tight-binding (TB) model Hamiltonians. Based on the Slater-Koster TB parameterization, it builds first-principles equivalent electronic models using a minimal-basis set. By incorporating the localized chemical environment of atoms/bonds into the TB parameters, DeePTB achieves TB Hamiltonian predictions with near-DFT accuracy across a range of key material systems. By integrating with software like DeePMD-kit and TBPLaS, it enables the calculation and simulation of electronic structure properties and photoelectric responses in large-scale systems of up to millions of atoms in finite-temperature ensembles. This groundbreaking advancement has garnered widespread attention in the academic community and was ultimately published in Nature Communications. For more technical details on the DeePTB version, interested readers can refer to the DeePTB article in Nat Commun 15, 6772 (2024). + + + +## DeePTB v2: A Comprehensive Upgrade for LCAO Quantum Operators +During the review and publication process of the v1 version, the DeePTB project team did not remain idle. In July of this year, the team released DeePTB v2 [2], which involved a thorough restructuring and reorganization compared to v1. This new version integrates the deep learning representation of the TB Hamiltonian with E3 equivariant representations, including quantum operator matrices like the KS Hamiltonian and density matrix, within a unified software framework. Both the Slater-Koster TB and LCAO Kohn-Sham (KS) Hamiltonians are Hamiltonian operators represented under the Linear Combination of Atomic Orbitals (LCAO) framework. The key difference is that the Slater-Koster TB Hamiltonian is more constrained, particularly by the two-center approximation, and often uses fewer basis sets. The construction method used in v1 for the Slater-Koster TB Hamiltonian leverages the rotation of the Wigner-D matrix, enabling efficient parallel construction of the TB Hamiltonian matrix. As a result, the efficiency of v2 is significantly improved compared to v1. + +In response to the high computational demands and parallelization challenges associated with the equivariant representation of quantum operators under the LCAO basis set, the DeePTB team implemented a solution that accelerates tensor operations using SO2. Additionally, to address the issue of the increasing receptive field with each iteration in MPNN networks, they designed a strictly localized equivariant message-passing model for representing single-particle operator matrices under the LCAO basis set, called SLEM (Strictly Localized Equivariant Message-passing). DeePTB v2 also flexibly supports the option to turn off the strict locality constraint, in which case the model is called LEM (Localized Equivariant Message-passing). The release of DeePTB v2 marks the evolution of DeePTB from a specialized TB model solution to a more general framework for accelerating first-principles calculations. Below, we introduce one of the core innovations of DeePTB v2, the SLEM model. For more details, please refer to the article: [https://arxiv.org/abs/2407.06053](https://arxiv.org/abs/2407.06053). + +## Background and Principles of the SLEM Scheme +Predicting quantum operator matrices (such as Hamiltonians, overlap matrices, and density matrices) within the Density Functional Theory (DFT) framework is crucial for understanding material properties, but efficiently and scalably predicting these for large systems remains a challenge. Existing Message Passing Neural Network (MPNN) methods, though highly accurate on reported datasets, face limitations in parallelization, generalization, and scalability due to their iterative update mechanism, which expands the receptive field (i.e., the range over which nodes aggregate information). This challenge is even more pronounced in quantum operator prediction tasks, which involve handling high-dimensional variables. Therefore, a new strictly localized message-passing mechanism is needed to improve parallelization and scalability while maintaining high accuracy for handling large, complex systems. + +In traditional Message Passing Neural Networks (MPNNs), each round of node/edge feature updates depends on the updated features of nodes/edges from the previous layer. This update mechanism causes the receptive field to expand with the number of layers. As shown in Figure 1(a), after two layers of updates, the receptive field of a node expands twice from its initial neighborhood r_cut. This expansion makes each node/edge's output feature dependent on a vast input atomic/chemical bond environment, posing challenges for parallelization and scalability. In contrast, SLEM adopts a strictly localized feature update approach. "Strict locality" means that when updating node or edge features, it only relies on atomic environment information within a fixed range, which does not expand with network depth. As illustrated in Figure 1(b), for node updates, the update of the L-th layer node only depends on the features of the same node from the L-1 layer and the neighbor nodes from the L=0 layer. Through a clever message-passing mechanism design, the SLEM model consistently keeps the receptive field within a predefined local range while maintaining excellent expressive capability. + +
+ +## SLEM Model Architecture +The SLEM model utilizes equivariant neural networks to parametrize quantum operators such as Hamiltonians and density matrices. For the overlap integral matrix, SLEM leverages the strict two-center characteristic of orbital overlap integrals, employing Slater-Koster parameterization to achieve an invariant representation of the overlap integral matrix. Thanks to the unified framework of TB and E3 equivariant representation in the v2 version, SLEM significantly reduces the computational cost of fitting the overlap integral matrix. + +
+ +This section focuses on the strictly localized equivariant representation scheme of the SLEM model. As shown in Figure 2, the SLEM model is primarily composed of the following parts: + +1) Input Encoding: Encodes the physical and chemical information, such as atom types, coordination numbers, and distances, into hidden scalar features. + +2) Feature Initialization: Initializes edge, hidden state, and node features using encoded scalars and spherical harmonics. + +3) Feature Update Module: Iteratively updates the hidden state features, node features, and edge features through a series of strictly localized node/edge information update operations. + +4) Quantum Operator Matrix Reconstruction: Reconstructs quantum operators such as Hamiltonians and density matrices using the updated node and edge features. + +In summary, the SLEM model, through its strictly localized message-passing scheme, considers only the atomic environment within a fixed range when updating node and edge features, thereby avoiding the unlimited expansion of the receptive field. This design not only significantly improves data utilization efficiency and reduces computational costs but also removes technical barriers to parallelization, enabling efficient simulations on ultra-large systems. Additionally, for flexibility, DeePTB has also implemented a traditional MPNN-like scheme in the software that removes the strict locality constraint, instead using a learnable distance-weighted scheme to achieve equivalent locality, known as the LEM (Localized Equivariant Message-passing) model. Whether using SLEM or LEM, all equivariant models implemented in DeePTB v2 incorporate an efficient SO(2) convolution scheme, reducing the computational complexity of tensor products from \(O(l^6)\) to \(O(l^3)\), which provides strong support for handling systems with heavy elements (where DFT calculations require the inclusion of high angular momentum basis sets such as f and g orbitals). + +In validation tests, DeePTB v2 demonstrated outstanding performance. The accuracy of Hamiltonian predictions reached sub-meV levels, and the prediction error for electron density and overlap matrices was on the order of (~1e-5), approaching the machine precision of single-precision floating-point numbers. Notably, due to DeePTB v2's ability to predict both Hamiltonians and overlap matrices simultaneously, the model operates independently of DFT software during inference. This greatly simplifies the DeePTB usage process, lowering the barrier for users. Furthermore, the clever Slater-Koster parameterization scheme allows the inclusion of overlap matrix training with minimal increase in model parameters and training time. Additionally, the strictly localized design of the SLEM model facilitates multi-GPU parallel inference and large-scale simulation applications in the future. + +## DeePTB Data Preprocessing Tool: dftio +During the development and application of DeePTB, the team realized that converting DFT output data into inputs for machine learning models is not an easy task, especially when dealing with different DFT software and training objectives. Users often need to overcome certain barriers, such as understanding the format of DFT data and the requirements of the model input, and then writing specific processing scripts for data preprocessing. To facilitate efficient reading, writing, and format conversion of electronic structure data from DFT software for users and the developer community, the DeePTB team initiated the dftio project. dftio aims to support the direct conversion of outputs from various DFT software into standard data formats required for electronic structure model training, as well as provide support for reading datasets in these standard formats. This significantly lowers the barrier to using electronic structure models like DeePTB and promotes the dissemination of data and methods. Moreover, with the convenience of a unified format, users can complete data conversion with just one command using dftio, without having to deal with complex data processing details, achieving a "what you see is what you get" experience. Additionally, dftio adopts a modular design, offering flexible interfaces, allowing users or developers to easily add support for new DFT software. + + +## The Future of DeePTB: Collaborative Creation +Finally, while DeePTB has made significant progress and achievements, there are still many challenges to overcome on the path to a comprehensive revolution in first-principles calculations. To further enhance DeePTB’s performance and applicability, the DeePTB team is exploring more potential application scenarios with their partners. As an open-source project, the DeePTB team sincerely invites all interested colleagues to join. Whether you contribute valuable data resources, participate in model or software development, or provide suggestions for improvement, every contribution will help DeePTB reach higher goals. Various forms of collaboration are welcome, including but not limited to internships, visits, postdoctoral research, and other cooperative studies. We also encourage communication and discussion with the DeePTB team via GitHub Issues, email, or other means. + +DeePTB is currently open-sourced in the DeepModeling community. We welcome you to use or join the project. + +DeePTB Project Link: (https://github.com/deepmodeling/DeePTB) + +The dftio project is in the process of applying to be hosted in the DeepModeling community, so stay tuned for more details. diff --git a/source/_posts/dflow.md b/source/_posts/dflow.md new file mode 100644 index 00000000..c7ed6ec7 --- /dev/null +++ b/source/_posts/dflow.md @@ -0,0 +1,64 @@ +--- +title: "The cloud-native AI4Science workflow framework Dflow | Enhances the development of scientific computing software and the OpenLAM model" +date: 2024-05-10 +categories: +- Dflow +--- + +From the development of software ecosystems in fields such as electronic structure calculations and molecular dynamics, to the systematic evaluation of large models like OpenLAM, and gradually addressing scientific and industrial R&D problems such as biological simulations, drug design, and molecular property prediction, a series of AI4Science scientific computing software and models are rapidly advancing. This progress is closely linked to better research infrastructure, with the Dflow project being a key component. + + +AI advancements are driving a paradigm shift in scientific research, but the integration of scientific computing and AI faces challenges, such as the complex processes of efficient data generation and model training, and the management and scheduling of large-scale tasks. Traditional manual task management is inefficient, and script-based automation lacks reusability and maintainability. The rapid scalability of cloud computing offers new opportunities for scientific research, necessitating a new, user-friendly workflow framework that can effectively utilize cloud and high-performance computing resources, enabling seamless integration of algorithm design and practical application. + +In this context, the DeepModeling community initiated and gradually improved Dflow[1,2], a Python toolkit designed to help scientists build workflows. The core features of Dflow include: + +1. Enabling complex process control and task scheduling. Dflow integrates Argo Workflows for reliable scheduling and task management, uses container technology to ensure environmental consistency and reproducibility, and employs Kubernetes technology to enhance workflow stability and observability, capable of handling workflows with thousands of concurrent nodes. + +2. Adapting to various environments and supporting distributed and heterogeneous infrastructure. Dflow services can run on both single machines and large Kubernetes clusters based on the cloud. Additionally, Dflow easily interfaces with high-performance computing (HPC) environments and the Bohrium® cloud computing platform specifically designed for scientific research, making it suitable for diverse computing needs. + +3. Offering simple interfaces, flexible rules, and local debugging support. Before workflow submission, exception handling and fault tolerance strategies can be set. Dflow also provides a flexible restart mechanism, allowing seamlessly integrating previously completed steps into new workflows. Dflow's debug mode supports running workflows locally without using containers, offering an experience consistent with Argo Workflows. + +The diagram below illustrates Dflow within the AI for Science computing framework: +
+ + + + +So far, many workflow projects have been developed based on Dflow, covering various fields from electronic structure calculations and molecular dynamics to biological simulations, drug design, material property predictions, and automated software testing. Representative open-source software includes: + +- [APEX](https://github.com/deepmodeling/apex): Workflow for alloy property calculations. + +- [DPGEN2](https://github.com/deepmodeling/dpgen2): Second-generation DP potential generator. + +- [Rid-kit](https://github.com/deepmodeling/rid-kit): Enhanced dynamics toolkit. + +- [DeePKS-flow](https://github.com/hustlingFive/deepks-flow): Building machine learning density functionals. + +- [VSW](https://github.com/dp-yuanyn/virtual-screening-workflow): Virtual screening workflow in drug design. + +- [ABACUS](https://deepmodeling-activity.github.io/abacus-test.github.io/index.html?pname=performance): Automated evaluation workflow. + +- [Dflow-galaxy](https://github.com/chenggroup/dflow-galaxy): Series of tools and workflows based on Dflow and ai2-kit. + +- [ir-flow](https://github.com/tfzx/IR-Raman-Workflow): Spectral calculation workflow. + +- [ThermalConductivity-Workflow](https://github.com/gdbhcxhmjk-z/ThermalConductivity-Workflow): Thermal conductivity calculation workflow. + +There are also various industrial application software or computing platforms developed based on the Dflow framework, achieving systematic progress. + +
+ +
+ + +These extensive applications demonstrate the openness and scalability of Dflow. Additionally, the basic units in Dflow (called OPs) can be reused across different workflow applications. The Dflow ecosystem has accumulated a set of reusable OPs, such as the collection related to first-principles calculations—the FPOP project (Project link: https://github.com/deepmodeling/fpop). These components not only facilitate the development of complex workflows within the scientific community but also provide researchers with a collaborative environment to share best practices and innovations. The community ecosystem, driven by an open and scalable architecture, keeps Dflow at the forefront of workflow management, providing robust support for the evolving needs of the scientific and technological community. + +In previous versions, the requirement to set up an Argo server posed a challenge for some novice users. Subsequently, the core developers of Dflow, based on the Bohrium research cloud platform, provided users with an out-of-the-box workflow middleware service (https://workflows.deepmodeling.com/), along with a beginner's guide based on Bohrium Notebook. + +notebook link: https://bohrium.dp.tech/notebooks/1211442075 + +If you are also interested in developing an efficient, user-friendly, and automated workflow in the AI4Science era, you are welcome to embrace Dflow. + +[1] https://github.com/deepmodeling/dflow + +[2] https://arxiv.org/abs/2404.18392 \ No newline at end of file diff --git a/source/_posts/unimol.md b/source/_posts/unimol.md new file mode 100644 index 00000000..5548e8dd --- /dev/null +++ b/source/_posts/unimol.md @@ -0,0 +1,46 @@ +--- +title: "Uni-Mol: Partnering with the DeepModeling Community to Build a Foundational Model for Molecular Design" +date: 2024-07-05 +categories: +- Uni-Mol +--- + +Pre-trained models are sweeping through the AI field by extracting representative information from large-scale unlabeled data and then performing supervised learning on small-scale labeled downstream tasks, becoming the de facto solution in many application scenarios. In drug design, there is still no consensus on the "best way to represent molecules." In the field of materials chemistry, predicting molecular properties is equally important. Mainstream molecular pre-training models typically start from one-dimensional sequences or two-dimensional graph structures, but molecular structures are inherently represented in three-dimensional space. Therefore, directly constructing pre-trained models from three-dimensional information to achieve better molecular representations has become an important and meaningful problem. To further promote research on molecular representation and pre-trained models, Uni-Mol will join the DeepModeling community to work with community developers to advance the development of a three-dimensional molecular representation pre-training framework. + + + +## Background of Pre-trained Models and Molecular Representation Learning +Pre-trained models achieve efficient model training and performance improvement by extracting representative information from large-scale unlabeled data and then performing supervised learning on small-scale labeled downstream tasks. Especially in fields like natural language processing and computer vision, pre-trained models have shown significant advantages. + +In the field of molecular representation learning, researchers have also begun to use pre-trained models to enhance molecular representation capabilities. Traditional molecular pre-trained models mainly start from one-dimensional sequences (such as SMILES strings) or two-dimensional graph structures (such as molecular topology graphs). However, molecular structures are inherently represented in three-dimensional space, and ignoring this high-dimensional information limits the expressive power and application range of existing methods. Especially in fields like drug design, although these models perform well in limited supervised data learning, their performance is not ideal when dealing with tasks related to three-dimensional geometry. + +Therefore, constructing pre-trained models directly from three-dimensional information to obtain more accurate and comprehensive molecular representations has become an important and meaningful research problem. This approach can better capture the three-dimensional characteristics of molecular structures and play a greater role in downstream tasks such as geometric prediction and molecular generation. With advances in computational resources and algorithmic technologies, three-dimensional molecular pre-trained models are gradually becoming a new hotspot in molecular representation learning research, driving the field forward. + +This research background, which integrates pre-trained models and molecular representation learning, demonstrates the broad application potential of AI technology in scientific research, providing new ideas and tools for future molecular design and materials science research. Accordingly, we have developed Uni-Mol, a general three-dimensional molecular representation learning framework that greatly expands the expressive power and application range of the method. + +
+ + +## Introduction to Uni-Mol +In May 2022, the open-source general 3D molecular representation learning framework based on molecular three-dimensional structure, Uni-Mol, was officially launched, and the paper was accepted by the top machine learning conference ICLR 2023. Unlike previous molecular representation frameworks based on one-dimensional sequences or two-dimensional graph structures, Uni-Mol directly uses the three-dimensional structure of molecules as model input. Uni-Mol excels in performance and model generalization ability, surpassing existing solutions in tasks such as small molecule property prediction, protein target prediction, protein-ligand complex conformation prediction, quantum chemical property prediction, MOF material adsorption performance prediction, and OLED luminescent material performance prediction. + +The Uni-Mol framework mainly includes two models: a molecular pre-training model trained using the three-dimensional conformations of 209 million molecules, and a pocket pre-training model trained using 3 million candidate protein data. These two models can be used independently for different tasks or combined for protein-ligand binding tasks. Uni-Mol outperforms current state-of-the-art techniques in 14 out of 15 molecular property prediction tasks. Additionally, Uni-Mol delivers excellent prediction results in three-dimensional space tasks such as protein-ligand binding mode prediction and molecular conformation generation. + +Besides Uni-Mol, the open-source models based on Uni-Mol include Uni-Mol+, Uni-Mol Tools, and Uni-Mol Docking V2. Uni-Mol+ is a model specifically designed for quantum chemical property prediction. By generating and optimizing initial three-dimensional conformations of two-dimensional molecular graphs, it achieves high-precision quantum chemical property predictions, significantly surpassing current state-of-the-art methods in multiple benchmark tests. Uni-Mol Tools is a set of user-friendly wrappers that support molecular property prediction, molecular representation, and other downstream tasks, providing a complete suite of practical tools based on the Uni-Mol model. Uni-Mol Docking V2 is the latest binding conformation prediction model, performing excellently in the PoseBusters benchmark test, with over 77% of predicted ligand binding conformations being accurate and RMSD values less than 2.0 Å. The generated prediction results are chemically accurate, avoiding issues such as chirality flipping and spatial conflicts. We will continue to open-source the latest foundational models and user-friendly toolkits and welcome contributions from the community, including models, tools, and documentation. + +## Uni-Mol Application Research Achievements +Currently, numerous researchers from various fields are using Uni-Mol for downstream application research, with articles published in top journals and international conferences such as Nature Communications, Journal of the American Chemical Society, Advanced Optical Materials, and NeurIPS. Uni-Mol+ will also be published in Nature Communications soon. Additionally, many research articles using Uni-Mol have been released in preprint form. + +## Future Development Plans for Uni-Mol +- Continually contributing to the community by improving the code, examples, and data, and consistently updating more downstream application cases. +- Open-sourcing more models and data, including the upcoming upgraded versions of Uni-Mol2 and Uni-Mol Docking. +- Iteratively updating versions of Uni-Mol Tools, adding new features, and supporting more data types, custom pre-training, and multi-type fine-tuning. + +## Uni-Mol in the DeepModeling Community +In the context of the current era of artificial intelligence and big data, Uni-Mol's integration into the DeepModeling open-source software community will provide the AI4S community with an efficient three-dimensional molecular pre-training framework, promoting collaborative research and development in molecular representation learning and pre-trained models. + +[Project Address](https://github.com/deepmodeling/Uni-Mol) + +The Uni-Mol code is now open-source in the DeepModeling community. Feel free to use or join the project. + +If you are interested in Uni-Mol or have new ideas, you are welcome to contact us via GitHub. If you wish to use Uni-Mol for research, please follow our [website](https://deepmodeling.com). \ No newline at end of file From 8ce5a87fd981da366ec7700d5e3f12846145c99e Mon Sep 17 00:00:00 2001 From: Yani Guan Date: Wed, 13 Nov 2024 17:48:14 -0800 Subject: [PATCH 2/2] update deepflame version1.4 --- source/_posts/deepflame_v1d4.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/_posts/deepflame_v1d4.md b/source/_posts/deepflame_v1d4.md index 91748d9e..678b1ccb 100644 --- a/source/_posts/deepflame_v1d4.md +++ b/source/_posts/deepflame_v1d4.md @@ -1,5 +1,5 @@ --- -title: DeepFlame 1.4 Released, Introducing Full-Speed Range Multiphase Reactive Flow Solver" +title: "DeepFlame 1.4 Released, Introducing Full-Speed Range Multiphase Reactive Flow Solver" date: 2024-08-23 categories: - DeepFlame