Material autonomous discovery method and system based on large language model

Abstract

This invention relates to the fields of artificial intelligence and computational materials science, and discloses a method and system for autonomous material discovery based on a large language model. The method includes: the system receiving computational task instructions in natural language form; a cognitive layer calling a large language model agent to process the instructions and outputting structured instructions containing action instructions and parameter sets; a control bridging layer merging and pattern-validating the parameter sets based on preset system parameters, generating file entities and writing them to the processing path; an execution layer starting a background daemon process and triggering atomic movement instructions from the operating system; a computation module parsing the file entities, initializing a graph neural network model, and performing iterative computation; during the computation process, collecting and transmitting runtime status data including a loss function, and having the large language model agent dynamically generate the next round of computational task instructions based on the numerical values. This invention establishes a closed loop of instruction parsing, mutual exclusion scheduling, and physical computation, improving the stability of autonomous material computation.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence and computational materials science and technology, specifically to a method and system for autonomous material discovery based on a large language model. Background Technology

[0002] In recent years, artificial intelligence technology has been increasingly applied to the field of computational materials science. By introducing large language models to parse natural language commands, it can assist researchers in carrying out tasks such as materials discovery and property prediction. However, existing autonomous materials computation and discovery systems still have some technical shortcomings in practical applications.

[0003] During the instruction parsing and task initialization phases, the initial parameters extracted by the system often lack strict standards due to the lack of standardized natural language expressions. Existing technologies largely rely on manually pre-setting fixed parameter templates, lacking mechanisms for automatic parameter validation and dynamic completion based on hierarchical priority. When external input parameters are incomplete, it can easily lead to parameter parsing omissions or data type conflicts, causing subsequent computation tasks to be interrupted and reducing the accuracy of task initialization.

[0004] In multi-process concurrent computing environments, existing systems typically use conventional application-level file read / write status marking when handling task scheduling and file transfer. This approach lacks a low-level mutual exclusion protection mechanism for file entities. When multiple computing processes simultaneously attempt to acquire underlying hardware computing resources and read files to be processed, resource contention and concurrent read / write conflicts can easily arise, causing task scheduling errors and affecting the overall operational stability of the system.

[0005] In terms of performing physical model calculations and task iterations, existing graph neural networks often lack smooth control over the handling of spatial truncation boundaries when calculating the energy and force data of atoms. This results in calculations when atoms cross the truncation radius failing to meet the physical requirement of second-order continuous differentiability. Furthermore, existing computing systems cannot autonomously plan the next step based on runtime data after a single task completion. Researchers must manually monitor the convergence state of the loss function and adjust parameters accordingly before issuing the next round of calculation instructions. This reliance on manual intervention disrupts the automatic feedback loop based on physical calculation results, limiting the continuity of the autonomous materials discovery process. Summary of the Invention

[0006] To address the shortcomings of existing technologies, this invention provides a method and system for autonomous material discovery based on a large language model. This solves the problems in existing material calculation systems, such as task interruption due to incomplete external input parameters, resource contention and read / write conflicts in multi-process concurrent environments, discontinuous physical boundary calculations, and reliance on manual intervention in the task iteration process.

[0007] To achieve the above objectives, the first aspect of this invention provides a method for autonomous material discovery based on a large language model, comprising the following steps: The system receives computation task instructions in natural language. The cognitive layer invokes a large language model agent to process the computational task instructions and outputs a structured instruction containing action instructions and a set of parameters. The control bridging layer extracts the parameter set from the structured instructions, combines it with the system preset parameters for merging and pattern verification, serializes the verified parameter objects into file entities and writes them to the storage path to be processed. The execution layer starts a background daemon process to poll the pending storage path, triggering the operating system's atomic move instruction to transfer the file entity to the running storage path; The computation module of the execution layer parses the file entity, initializes the graph neural network model, and performs iterative computation. During the iterative calculation process, running status data containing the loss function value is collected, and the running status data is sent back to the large language model agent in the cognitive layer; the large language model agent dynamically generates the calculation task instructions for the next round based on the loss function value.

[0008] Preferably, the process by which the cognitive layer invokes the large language model agent to process the computational task instructions specifically includes: The format specification constraints, the description information of the toolset, and the natural language instructions input from the outside are concatenated to generate prompt words for input; the format specification constraints adopt the JSON Schema data exchange format, and the toolset includes graph neural network model training tools, molecular spatial configuration optimization tools, and material physical property inference tools; The large language model agent processes the prompt word input according to the format specification constraints, performs a logical reasoning process, and maps the natural language text into discrete actions within a predefined set of preset actions, with each discrete action corresponding to an action instruction. The output of the large language model agent is constrained to be a JSON string conforming to the JSON Schema template structure.

[0009] Preferably, the merging process and pattern verification based on system preset parameters specifically include: Load system default parameters and static configuration files as system preset parameters, map the extracted parameter set to a dynamic parameter space, parse the static configuration file and generate a static parameter space, and read the system's internal preset system default parameter space; Establish a parameter coverage priority strategy, which limits the priority of the dynamic parameter space to higher than that of the static parameter space, and at the same time limits the priority of the static parameter space to higher than that of the system default parameter space; According to the parameter coverage priority strategy, a recursive merging operation is performed to integrate the system default parameter space, the static parameter space, and the dynamic parameter space, and the final configuration object is output as the merged parameter object; The merged parameter object is subjected to pattern validation using a data validation framework that includes preset data type validation rules and numerical boundary validation rules.

[0010] Preferably, the step of triggering the operating system's atomic move instruction to transfer the file entity to the runtime storage path specifically includes: Define a task state space that includes pending state, running state, completed state, and failed state, and mark file entities in the pending storage path as pending state that do not occupy underlying computing resources; The background daemon process calls the operating system's underlying file renaming interface to execute the atomic move instruction, changing the path prefix of the file entity to the running storage directory. The atomic move operation corresponding to the atomic move instruction constitutes a mutex lock in a multi-process concurrent computing environment, exclusively acquiring the processing permission of the file entity. After obtaining processing permissions, the status of the file entity is updated to the running status. When the computing task corresponding to the file entity is completed and no system exception is triggered, it is updated to the completed status. When an exception occurs, it is updated to the failed status. The running status of the current computing task is updated synchronously.

[0011] Preferably, the initialization of the graph neural network model and the execution of iterative calculations specifically include: Allocate underlying hardware computing resources and execute iterative calculations of the graph neural network model using a full-precision numerical format; Based on the dataset path parameters inside the file entity, the corresponding material dataset is read from the system storage medium, and three-dimensional spatial structure data containing atomic three-dimensional coordinate data and atomic number data is extracted. The Euclidean distance between nodes is calculated based on the three-dimensional coordinate data, and the distance between nodes is mapped to a continuous expression of the Gaussian radial basis function. Expand the basis function set within the set cutoff radius, and use a cosine smooth cutoff function for attenuation control, so that the cosine smooth cutoff function continuously decays to zero at the set cutoff radius.

[0012] Preferably, the step of performing iterative calculations of the graph neural network model using a full-precision numerical format further includes: The deep graph neural network module, which combines the basis function set and the atomic number data, outputs predicted energy data and calculates the negative gradient of the predicted energy data with respect to the three-dimensional coordinates of the atom to output predicted force data. Obtain the actual potential energy data and actual force data calculated using first-principles calculations, and establish a joint energy-force loss function; An adaptive moment estimation optimizer is employed, combined with a cosine annealing learning rate decay strategy that dynamically reduces the optimizer's learning rate based on the progress of training epochs, to perform parameter update iterations.

[0013] Preferably, the step of dynamically generating the next round of computation task instructions based on the loss function value specifically includes: The large language model agent in the cognitive layer receives the running status data and dynamically generates parameter adjustment strategies or calculation task instructions for the next round based on the convergence status of the loss function value or the result of the data inference operation. The large language model agent will re-output the updated computation task instructions or the parameter adjustment strategy as new structured instructions.

[0014] A second aspect of this invention provides a material autonomous discovery system based on a large language model, comprising: The cognitive layer is equipped with a large language model intelligent agent, which is used to receive natural language instructions from external input and output structured instructions containing action instructions and parameter sets. The control bridging layer establishes a communication connection with the cognitive layer to extract the parameter set from the structured instructions, performs merging and pattern verification in combination with system preset parameters, and generates a configuration file and writes it to the storage path to be processed after the verification is passed. The execution layer, connected to the control bridge layer, includes a buffer scheduling module and a computation module. The buffer scheduling module is used to transfer the configuration file to the runtime storage path using atomic move instructions from the operating system. The computation module is used to parse the configuration file to initialize the graph neural network model and perform iterative computation, extracting runtime state data containing the loss function value and sending it back to the cognitive layer. The large language model agent is used to dynamically generate the computation task instructions for the next round based on the loss function value.

[0015] Preferably, when the control bridging layer performs merging processing in conjunction with system preset parameters, it loads static configuration files and system default parameters, limits the priority of the dynamic parameter space mapped by the parameter set to higher than the static parameter space parsed by the static configuration file, and limits the priority of the static parameter space to higher than the system default parameter space preset within the system. It integrates and outputs the final configuration object as the merged parameters, and performs the pattern verification on the final configuration object through a data verification framework that includes preset data type verification rules and numerical boundary verification rules.

[0016] Preferably, the buffer scheduling module includes a background daemon process module, which continuously polls the storage directory to be processed, calls the underlying file renaming interface of the operating system to initiate the atomic move instruction, moves the configuration file to the running storage directory, and forms a mutex lock with exclusive processing rights in a multi-process concurrent computing environment. When performing the iterative calculation, the calculation module reads the material dataset according to the configuration file, extracts the three-dimensional spatial structure data containing the three-dimensional coordinate data and atomic number data of atoms, calculates the Euclidean distance between nodes based on the three-dimensional coordinate data of the atoms, expands the basis function set within the set cutoff radius and uses a cosine smoothing cutoff function to control the continuous decay of the boundary, calculates the negative gradient of the predicted energy data with respect to the three-dimensional coordinates of the atoms based on the basis function set and the atomic number data to obtain the predicted force data, and establishes a joint energy force loss function.

[0017] This invention provides a method and system for autonomous material discovery based on a large language model. It has the following beneficial effects: 1. This invention transforms natural language instructions into structured instructions subject to standardization through a cognitive layer, and performs recursive merging operations of dynamic parameters, static configurations, and system default parameters according to preset priorities. It can automatically complete the parameter information required for material calculation based on the system's basic configuration when the original external input parameters are incomplete, avoiding task interruption caused by parameter parsing omissions or data type conflicts, and improving the accuracy of front-end instruction parsing and back-end calculation task initialization.

[0018] 2. This invention utilizes a background daemon process to poll the storage path to be processed and executes atomic move instructions by calling the file renaming interface at the operating system level to transfer the configuration file. By using the operating system level mechanism, an exclusive processing mutex lock for file entities is constructed in a multi-process concurrent computing environment, eliminating resource contention and concurrent read / write conflicts during the allocation of underlying hardware computing resources, and ensuring the stability of concurrent scheduling and running status updates of multiple computing tasks.

[0019] 3. When performing iterative calculations using a graph neural network, the computation module of this invention employs a cosine smoothing truncation function to control the set of basis functions to continuously decay to zero at a set truncation radius. This satisfies the second-order continuous differentiability requirement for energy and force calculations when atoms cross boundaries. Simultaneously, the system feeds back the convergence state of the loss function during the calculation process to the large language model agent in the cognitive layer. The large language model agent then dynamically generates the next round of task instructions based on this state, forming a closed-loop feedback mechanism that automatically iterates based on the physical calculation results. This reduces the manual monitoring and adjustment steps in the material discovery process. Attached Figure Description

[0020] Figure 1 This is a schematic diagram of the overall architecture of the material autonomous discovery system of the present invention; Figure 2 This is a schematic diagram of the main process of the material autonomous discovery method of the present invention; Figure 3 This is a line chart comparing the concurrent scheduling of video memory usage in the system according to the present invention. Figure 4 This is a bar chart comparing the prediction error and reproducibility of the graph neural network model of the present invention. Detailed Implementation

[0021] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] See attached document Figure 1 This invention provides a material autonomous discovery system based on a large language model intelligent agent and a configuration-driven architecture, which includes a cognitive layer, a control bridging layer and an execution layer.

[0023] The cognitive layer is equipped with a large language model agent. The cognitive layer receives natural language instructions from external input. The cognitive layer processes these natural language instructions through the large language model agent. The cognitive layer outputs structured instructions. These structured instructions follow a predefined format.

[0024] The control bridging layer establishes a communication connection with the cognitive layer. The control bridging layer receives structured instructions. It extracts the parameter vector from the structured instructions. The control bridging layer stores static configuration files and default parameters. It merges the parameter vector, static configuration file, and default parameters according to a preset priority hierarchy. The control bridging layer performs data type and boundary checks on the merged parameters. After successful checks, the control bridging layer generates a configuration file.

[0025] The execution layer connects to the control bridge layer. The execution layer contains a buffer scheduling module and a computation module. The buffer scheduling module monitors the status of the task directory. It transfers configuration files through atomic operations of the operating system's file system. The computation module loads the graph neural network model. It reads the configuration file and initializes computational resources. It performs model training and data inference operations. It extracts performance metrics data during runtime. Finally, it transmits the performance metrics data to the front-end display interface.

[0026] See attached document Figure 2 This invention provides a method for autonomous material discovery based on a large language model intelligent agent and a configuration-driven architecture. This method is applied to the aforementioned autonomous material discovery system and specifically includes the following steps: The system receives computation task instructions in natural language.

[0027] The cognitive layer invokes the large language model agent to process computational task instructions. The large language model agent performs logical reasoning actions. The large language model agent outputs structured instructions that conform to the target format protocol. The structured instructions contain action instructions and associated parameter sets.

[0028] The control bridging layer intercepts structured instructions and extracts parameter sets. It loads system default parameters and static configuration files. Finally, it merges the parameter sets, static configuration files, and system default parameters.

[0029] The control bridging layer performs schema validation on the merged parameter objects. Validation items include data type checks and numerical range checks. If the validation passes, the control bridging layer serializes the parameter objects into independent file entities. The system then writes these file entities to the pending storage path.

[0030] The execution layer initiates a background daemon process to poll the pending storage paths. Upon detecting a file entity, the background daemon triggers an atomic move instruction from the operating system. This atomic move instruction moves the file entity from the pending storage path to the running storage path. The atomic move operation calls the operating system's underlying file renaming interface. The background daemon module changes the file entity's path prefix from the pending storage directory to the running storage directory. If multiple processes simultaneously request a path change for the same file entity, the operating system kernel mechanism ensures that only one process's change request succeeds and returns an acknowledgment signal. The system synchronously updates the running status of the current computing tasks.

[0031] The execution layer's computation module parses and runs file entities in the storage path. It initializes the graph neural network model based on the parsed parameters. The module allocates underlying hardware computing resources. Finally, it performs iterative computations on the graph neural network model using full-precision numerical formats.

[0032] During the iterative calculation process, the calculation module periodically collects the loss function values ​​and calculation progress information. The calculation module establishes a data feedback channel. Through this channel, the calculation module sends the loss function values ​​and calculation progress information to the control bridge layer and outputs them.

[0033] This invention provides a cognitive layer intent parsing mechanism, including: The cognitive layer deploys a large language model intelligent agent module. The system defines format specification constraints. These constraints use a structured protocol to set the grammatical boundaries of the data output.

[0034] The structured protocol uses the JSON Schema data exchange format. The system predefines valid tool actions and parameter types as JSON Schema templates. The output of the large language model agent module is enforced to be a JSON string conforming to this template structure.

[0035] The system encapsulates the underlying computational tasks into a set of tools with defined types. This set establishes the correspondence between underlying execution functions and logical processing instructions. The set includes action identifiers and parameter type declarations. It also includes tools for training graph neural network models, optimizing molecular spatial configurations, and inferring material physical properties.

[0036] The large language model agent module receives prompt input containing natural language text. The system concatenates the formatting constraints, the toolset description, and the externally input natural language commands to generate the prompt input. The toolset description includes the interface specifications of the underlying execution functions. The large language model agent module obtains the formatting constraints. The large language model agent module processes the prompt input according to the formatting constraints.

[0037] The large language model intelligent agent module performs the logical reasoning process. It maps natural language text into discrete actions within a pre-defined set of actions.

[0038] The large language model's agent module outputs structured instructions. These structured instructions conform to the syntactic constraints of the format specification. Each structured instruction contains discrete actions and associated parameter vectors.

[0039] Set the input prompt words as The computation process of the structured instructions output by the large language model intelligent agent module can be represented as follows: ; In the formula, Indicates that parameters are included. The large language model module; I represents structured instructions; This represents the selected discrete action, and the preset action set is set as follows. And satisfy ; Representing discrete actions The associated parameter vector.

[0040] Preset action set This is a predefined set of underlying legal computational tasks that the large language model intelligent agent module is allowed to invoke. The discrete actions in this predefined set correspond to the aforementioned toolset, specifically including graph neural network model training actions, molecular spatial configuration optimization actions, and material physical property inference actions. By limiting the selected discrete actions... Must belong to a set of preset actions The system restricts the output boundaries of the large language model intelligent agent module from a mechanism perspective, preventing it from generating fabricated instructions or unexpected computational actions that the system cannot parse, thereby ensuring the security and determinism of the underlying execution steps of material calculation.

[0041] The control bridging layer module receives structured instructions output by the large language model agent module. The control bridging layer module extracts discrete actions and parameter vectors.

[0042] The control bridging layer module performs parsing operations on the parameter vector. It compares the field data of the parameter vector with the parameter type declarations of the toolset.

[0043] The bridging layer module controls the completeness of the number of fields in the parameter vector. It also controls the specific data type of the parameter vector. Finally, it controls the output of the parameter vector after successful validation.

[0044] This invention provides a configuration-driven and state snapshot mechanism for controlling the bridging layer, including: The control bridging layer module receives the parameter vector from the structured instructions. The control bridging layer module then extracts the field data from the parameter vector.

[0045] The control bridging layer module reads the system's internal preset system default parameter space. The system default parameter space is denoted as... .

[0046] The control bridging layer module reads the static configuration file from the storage medium. The control bridging layer module parses the static configuration file and generates a static parameter space. The static parameter space is denoted as... .

[0047] The control bridging layer module maps the received parameter vectors to a dynamic parameter space. This dynamic parameter space is denoted as... .

[0048] The control bridging layer module establishes a parameter override priority strategy. This strategy prioritizes dynamic parameter spaces over static parameter spaces, and static parameter spaces over the system default parameter space. The priority relationship is expressed as follows: .

[0049] The control bridging layer module performs a recursive merging operation based on a parameter override priority strategy. It integrates the system default parameter space, static parameter space, and dynamic parameter space. Finally, the control bridging layer module outputs the final configuration object. This final configuration object is denoted as... The final calculation process for the configuration object is represented as follows: ; In the formula, This indicates the attribute override operator.

[0050] The control bridge layer module loads the data validation framework. The data validation framework includes preset data type validation rules and numerical boundary validation rules.

[0051] The control bridging layer module performs pattern validation on the final configuration object using a data validation framework. It verifies the data format of each field in the final configuration object and intercepts fields that do not conform to the preset data format.

[0052] The control bridging layer module performs a numerical range check on the final configuration object. The control bridging layer module also verifies the learning rate parameter. satisfy Control the bridging layer module to verify batch size parameters. satisfy .

[0053] in, Represents the set of positive real numbers; It represents the set of positive integers.

[0054] After completing and confirming that the mode verification has passed, the control bridging layer module performs a serialization operation on the final configuration object.

[0055] The control bridging layer module converts the serialized final configuration object into a single file entity. This file entity contains all the parameter attributes involved in the computation task. The file entity is stored in either YAML markup language format or JSON data format.

[0056] The control bridging layer module writes the file entity to the system's pending storage directory. The file entity serves as a configuration snapshot for the execution layer module to read and is used by the system to subsequently reproduce the corresponding computation task process.

[0057] This invention provides an asynchronous buffering and task scheduling mechanism based on atomic operations, which may include: The control bridging layer module writes the file entity containing the configuration snapshot to the system's pending storage directory. The execution layer module is configured with a state space mechanism and an asynchronous buffer queue.

[0058] The execution layer module defines the task state space. The task state space is denoted as... The task state space includes pending, running, completed, and failed states. The task state space is represented as follows: .

[0059] The execution layer module marks file entities in the storage directory to be processed as pending. The pending state is denoted as... Files in a pending state are in a suspended phase and do not consume underlying computing resources.

[0060] The execution layer module deploys a background daemon module. This background daemon module continuously polls the pending storage directory. It also detects newly added file entities within that directory.

[0061] Upon detecting a file entity, the background daemon module initiates an atomic move operation at the operating system level. This atomic move operation transfers the file entity from the pending storage directory to the running storage directory.

[0062] Atomic move operations constitute a mutex lock in a multi-process concurrent computing environment. The background daemon module exclusively acquires processing rights to file entities through atomic move operations. This mechanism isolates repetitive task execution instructions and resource contention conflicts.

[0063] After obtaining processing permissions, the background daemon module modifies the state of the file entity. The background daemon module updates the file entity's state to "running". The "running" state is denoted as... .

[0064] The background daemon module updates the file entity's status to "completed" when the computation task corresponding to the file entity is completed and no system exception is triggered. The completed status is denoted as... .

[0065] When a data blockage or underlying hardware failure occurs during the execution of a computing task, the background daemon module updates the file entity's status to a failure state. The failure state is denoted as... .

[0066] The execution layer module establishes the task state transition function. The task state transition function is denoted as... The task state transition calculation process of the execution layer module is represented as follows: ; In the formula, Indicates the current task status; Indicates the task status at the next moment; This indicates the status of the background daemon module acquiring the permission to handle mutex locks; The set of values ​​is ; This indicates that permission was successfully obtained; This indicates that the computation task was executed successfully; This indicates that an error has occurred during the execution of the computation task; This represents all other cases besides the three explicitly specified state transition conditions mentioned above.

[0067] The background daemon module removes file entities that are in a completed or failed state from the runtime storage directory. The background daemon module then archives the removed file entities to the corresponding history directory.

[0068] This invention provides a deterministic computation and closed-loop feedback mechanism for the execution layer, comprising: The execution layer module retrieves file entities from the runtime storage directory. It then parses these file entities. Finally, it initializes the depth graph neural network module and the data pipeline module based on the parameter data within the file entities.

[0069] The execution layer module configures the numerical precision of the underlying tensor operations. It sets the numerical format of the tensor operations to either single-precision floating-point or double-precision floating-point format. The execution layer module performs underlying tensor numerical calculations using either single-precision or double-precision floating-point format to avoid truncation errors in energy and force calculations caused by mixed-precision training.

[0070] The calculation module reads the corresponding material dataset from the system storage medium based on the dataset path parameters within the file entity. The calculation module then extracts the three-dimensional spatial structure data of the material system from the material dataset. This three-dimensional spatial structure data includes the three-dimensional coordinates and atomic number data of the atoms.

[0071] The three-dimensional coordinate data of an atom are denoted as , represented as Atomic number data are denoted as , represented as .

[0072] The calculation module calculates the Euclidean distance between nodes based on the 3D coordinate data. The distance between nodes is denoted as... The distance calculation process is expressed as follows: .

[0073] The calculation module maps the distances between nodes to a continuous expression of Gaussian radial basis functions. The calculation module sets the cutoff radius. The calculation module calculates the cutoff radius. Expand the set of basis functions within the range.

[0074] The first of the basis function set The process of expanding and calculating each feature component is represented as follows: ; In the formula, The central parameters of the basis functions representing an equidistant distribution. This represents a hyperparameter that controls the width of the Gaussian function. Represents the cosine smooth cutoff function; Representing nodes (atoms) With nodes (atoms) The distance between The expansion values ​​of Gaussian radial basis functions; Represented by natural constant An exponential function with base 0; Representing nodes (atoms) With nodes (atoms) The three-dimensional Euclidean distance between them. It continuously decays to zero.

[0075] Cosine smooth cutoff function The calculation process is expressed as: when Less than or equal to hour, ;when Greater than hour, This function ensures the second-order continuous differentiability of energy and force calculations when atoms cross the cutoff boundary. The computation module establishes a joint energy loss function. This joint energy loss function is used to optimize the weight parameters of the deep graph neural network module.

[0076] The calculation module acquires the actual potential energy data and actual force data calculated using first-principles calculations. The actual potential energy data is denoted as... .atom The actual force data received is denoted as .

[0077] The computation module outputs predicted energy data through the deep graph neural network module. The predicted energy data is denoted as... .

[0078] The calculation module performs a negative gradient operation on the predicted energy data with respect to three-dimensional coordinates. The calculation module outputs the predicted force data. The predicted force data is denoted as... The calculation process for predicting force data is expressed as follows: .

[0079] Calculate the total loss function of the module The calculation process is expressed as follows: ; In the formula, The weighting coefficients representing the energy loss values. The weighting coefficient represents the numerical value of stress loss. Indicates the total number of atoms; This represents the system's predicted energy data output by the deep graph neural network module; The mean squared error term is the square of the L2 norm (Euclidean norm) that represents the difference between the true and predicted values.

[0080] The computation module is configured with an adaptive moment estimation optimizer (AdamW optimizer) to perform parameter update iterations. The computation module is also configured with a cosine annealing learning rate decay strategy. This strategy dynamically reduces the optimizer's learning rate based on the progress of training epochs to avoid numerical oscillations around the optimal point during model training.

[0081] The execution layer module collects runtime status data during the iterative computation of model training. This runtime status data includes the current loss function value and training epoch progress data.

[0082] The execution layer module establishes a data streaming transmission channel between itself and the control bridging layer module.

[0083] The execution layer module sends runtime status data to the control bridge layer module via a data streaming transmission channel.

[0084] The control bridging layer module forwards runtime status data to the cognitive layer module and the front-end display interface module. The system completes the feedback data flow path from task command issuance and underlying execution to status display.

[0085] The large language model intelligent agent module in the cognitive layer receives this operational status data. Based on the convergence status of the loss function value or the results of data inference operations, the large language model intelligent agent module dynamically generates the next round of computation task instructions or parameter adjustment strategies. The large language model intelligent agent module re-outputs the updated computation task instructions as new structured instructions to achieve autonomous iteration and closed-loop optimization of the materials calculation process.

[0086] Specific application examples: The following section describes the material autonomous discovery method and system based on a large language model intelligent agent and configuration-driven architecture provided by this invention, using a specific application scenario as an example.

[0087] Experimental preparation and procedure: The system is configured with a hardware testing environment and a benchmark dataset. The publicly available QM9 molecular materials dataset is used as the benchmark dataset. The target prediction attribute set by the system is the energy difference between the highest occupied molecular orbital and the lowest unoccupied molecular orbital. This energy difference is denoted as the band gap. A baseline system is deployed simultaneously as a control group. The baseline system is configured in direct code generation mode and synchronous blocking scheduling mode.

[0088] The system receives natural language text containing the testing intent. The large language model agent in the cognitive layer receives the natural language text. The large language model agent maps the natural language text into action instructions and parameter vectors. The action instructions specify the training task for the startup graph neural network model.

[0089] The control bridging layer receives action commands and parameter vectors. It merges the parameter vectors with the system's default parameter space. It performs pattern validation on the merged parameter object. If the pattern validation passes, the control bridging layer generates a configuration file entity. The system writes the configuration file entity to the system's pending storage directory.

[0090] The background daemon in the execution layer polls the pending storage directory. The background daemon detects a newly added configuration file entity. The background daemon triggers an atomic move operation in the file system. The atomic move operation moves the configuration file entity to the runtime storage directory.

[0091] The computation module parses the configuration file entity. It then initializes the graph neural network model and underlying data pipeline based on this entity. The selected graph neural network models are SchNet and ViSNet. The module sets the cutoff radius of the Gaussian radial basis functions to 5.0 Å. It also sets the number of basis function centers to 50. Finally, it sets the initial learning rate of the optimizer to 0.0005.

[0092] The system distributes multiple pre-set training tasks to both the system of this invention and the baseline system. The computation module performs iterative calculations of the joint energy loss function using a full-precision numerical format. After completing the iterative calculations, the computation module outputs prediction error data on the test set and underlying runtime status data.

[0093] Experimental verification data and comparison results: By performing the above steps, the system obtained resource concurrency scheduling status data and model prediction accuracy error data. The experimental statistical results are shown in the table below: Table 1. Comparison of Concurrent Scheduling and Instruction Execution Data

[0094] Table 2. Prediction Error Data of Graph Neural Network Model Test Set

[0095] Experimental results show that in concurrent task allocation scenarios, the baseline system directly allocates underlying hardware resources. The baseline system's memory usage exhibits a linearly cumulative trend, triggering system node anomalies. Our system handles concurrent tasks through atomic move operations and asynchronous buffer queues. This system suspends queued tasks, maintaining peak memory usage within a constant threshold range. During instruction parsing, our system uses a pattern verification mechanism to intercept out-of-bounds parameter formats that do not conform to data type declarations. At the model computation level, our system employs full-precision computation and a configuration-driven architecture, achieving an average absolute error that meets benchmark requirements. The system repeatedly reproduces the same training task using independent configuration file entities, maintaining the prediction error fluctuation range within a preset tolerance range, thus verifying the determinism of the underlying numerical computation.

[0096] Experimental conclusion: See attached document Figure 3 With appendix Figure 4 The test results of the material autonomous discovery method and system based on large language model intelligent agent and configuration-driven architecture provided by this invention are as follows: In the concurrent scheduling memory usage test, the system's physical memory anomaly threshold was set to 24GB. Concurrent task allocation began at 10 seconds into the test. The baseline system's memory usage showed a continuous upward trend. At 20 seconds, the baseline system's memory usage reached 10GB. At 30 seconds, the baseline system's memory usage reached 18GB. At 40 seconds, the baseline system's memory usage reached 25GB. At 40 seconds, the baseline system's memory usage exceeded the 24GB system physical memory anomaly threshold, triggering an anomaly block. The system of this invention maintained a constant memory usage of 8GB during the 20-90 second runtime. At 100 seconds, after the task completion, the system's memory usage dropped back to an initial standby state of 2GB. This system uses an asynchronous buffering mode to control peak memory usage within a safe threshold range.

[0097] In the model prediction absolute error and reproducibility tests, the ViSNet model showed a mean absolute error of 0.112 eV for the target attribute test set, while the SchNet model showed a mean absolute error of 0.118 eV. The fluctuation range of the error range in multiple repeated experiments, as shown in the graph, was strictly controlled. This invention's system loads deterministic parameters through configuration file entities, eliminating the random execution bias caused by directly generating code from large language models, thus ensuring the accuracy and traceability of the underlying material physical quantity calculation results.

Claims

1. A method for autonomous material discovery based on a large language model, characterized in that, Includes the following steps: The system receives computation task instructions in natural language. The cognitive layer invokes a large language model agent to process the computational task instructions and outputs a structured instruction containing action instructions and a set of parameters. The control bridging layer extracts the parameter set from the structured instructions, combines it with the system preset parameters for merging and pattern verification, serializes the verified parameter objects into file entities and writes them to the storage path to be processed. The execution layer starts a background daemon process to poll the pending storage path, triggering the operating system's atomic move instruction to transfer the file entity to the running storage path; The computation module of the execution layer parses the file entity, initializes the graph neural network model, and performs iterative computation. During the iterative calculation process, running status data containing the loss function value is collected, and the running status data is sent back to the large language model agent of the cognitive layer; The large language model agent dynamically generates the next round of calculation task instructions based on the loss function value until the calculation task is completed, and outputs the attribute data of the target material as the autonomous discovery result.

2. The method for autonomous material discovery based on a large language model according to claim 1, characterized in that, The process by which the cognitive layer invokes the large language model agent to process the computational task instructions specifically includes: The format specification constraints, the description information of the toolset, and the natural language instructions input from the outside are concatenated to generate prompt words for input; The format specification constraints adopt the JSON Schema data exchange format, and the toolset includes graph neural network model training tools, molecular spatial configuration optimization tools, and material physical property inference tools; The large language model agent processes the prompt word input according to the format specification constraints, performs a logical reasoning process, and maps the natural language text into discrete actions within a predefined set of preset actions, with each discrete action corresponding to an action instruction. The output of the large language model agent is constrained to be a JSON string conforming to the JSON Schema template structure.

3. The method for autonomous material discovery based on a large language model according to claim 1, characterized in that, The merging and pattern verification process based on preset system parameters specifically includes: Load system default parameters and static configuration files as system preset parameters, map the extracted parameter set to a dynamic parameter space, parse the static configuration file and generate a static parameter space, and read the system's internal preset system default parameter space; Establish a parameter coverage priority strategy, which limits the priority of the dynamic parameter space to higher than that of the static parameter space, and at the same time limits the priority of the static parameter space to higher than that of the system default parameter space; According to the parameter coverage priority strategy, a recursive merging operation is performed to integrate the system default parameter space, the static parameter space, and the dynamic parameter space, and the final configuration object is output as the merged parameter object; The data validation framework, which includes preset data type validation rules and numerical boundary validation rules, verifies whether the data format of the merged parameter object conforms to the preset data type validation rules, and verifies whether the parameter value of the merged parameter object is within the range defined by the numerical boundary validation rules. The pattern validation is completed when both validations pass.

4. The method for autonomous material discovery based on a large language model according to claim 1, characterized in that, The atomic move instruction triggered by the operating system to move the file entity to the runtime storage path specifically includes: Define a task state space that includes pending state, running state, completed state, and failed state, and mark file entities in the pending storage path as pending state that do not occupy underlying computing resources; The background daemon process calls the operating system's underlying file renaming interface. The operation corresponding to the file renaming interface forms a mutex lock in a multi-process concurrent computing environment, exclusively acquiring the processing permission of the file entity. After obtaining processing permissions, the atomic move instruction is executed to change the path prefix of the file entity to the running storage path, so as to move the file entity to the running storage path, update the status of the file entity to the running status, and update the status to the completed status when the computing task corresponding to the file entity is completed and no system exception is triggered, and update the status to the failed status when an exception occurs, and synchronously update the running status of the current computing task.

5. The method for autonomous material discovery based on a large language model according to claim 1, characterized in that, The initialization of the graph neural network model and the execution of iterative calculations specifically include: Allocate underlying hardware computing resources and execute iterative calculations of the graph neural network model using a full-precision numerical format; Based on the dataset path parameters inside the file entity, the corresponding material dataset is read from the system storage medium, and three-dimensional spatial structure data containing atomic three-dimensional coordinate data and atomic number data is extracted. The Euclidean distance between nodes is calculated based on the three-dimensional coordinate data, and the distance between nodes is mapped to a continuous expression of the Gaussian radial basis function. Expand the basis function set within the set cutoff radius, and use a cosine smooth cutoff function for attenuation control, so that the cosine smooth cutoff function continuously decays to zero at the set cutoff radius.

6. The method for autonomous material discovery based on a large language model according to claim 5, characterized in that, The iterative computation of the graph neural network model using a full-precision numerical format also includes: The deep graph neural network module, which combines the basis function set and the atomic number data, outputs predicted energy data and calculates the negative gradient of the predicted energy data with respect to the three-dimensional coordinates of the atom to output predicted force data. Obtain the actual potential energy data and actual force data calculated using first-principles calculations, and establish a joint energy-force loss function based on the predicted energy data, the predicted force data, the actual potential energy data, and the actual force data; An adaptive moment estimation optimizer is employed, combined with a cosine annealing learning rate decay strategy that dynamically reduces the optimizer's learning rate based on the progress of training epochs, to perform parameter update iterations.

7. The method for autonomous material discovery based on a large language model according to claim 1, characterized in that, The specific steps of dynamically generating the next round of computation task instructions based on the loss function value include: The large language model agent in the cognitive layer receives the running status data and dynamically generates parameter adjustment strategies based on the convergence state of the loss function value, or dynamically generates the next round of computation task instructions based on the results of data inference operations. The large language model agent re-outputs the parameter adjustment strategy or the updated computational task instructions as new structured instructions.

8. A material autonomous discovery system based on a large language model, characterized in that, A method for autonomous material discovery based on a large language model, as described in any one of claims 1-7, includes: The cognitive layer is equipped with a large language model intelligent agent, which is used to receive natural language instructions from external input and output structured instructions containing action instructions and parameter sets. The control bridging layer establishes a communication connection with the cognitive layer to extract the parameter set from the structured instructions, performs merging and pattern verification in combination with system preset parameters, and generates a configuration file and writes it to the storage path to be processed after the verification is passed. The execution layer, connected to the control bridge layer, includes a buffer scheduling module and a computing module; The buffer scheduling module is used to transfer the configuration file to the runtime storage path using atomic move instructions from the operating system. The computing module is used to parse the configuration file to initialize the graph neural network model and perform iterative calculations, extract running state data containing loss function values ​​and send it back to the cognitive layer; The large language model agent is used to dynamically generate the next round of calculation task instructions based on the loss function value until the calculation task is completed, and outputs the attribute data of the target material as the autonomous discovery result.

9. A material autonomous discovery system based on a large language model according to claim 8, characterized in that, When the control bridging layer performs merging processing in conjunction with system preset parameters, it loads static configuration files and system default parameters, limits the priority of the dynamic parameter space mapped by the parameter set to higher than the static parameter space parsed by the static configuration file, and limits the priority of the static parameter space to higher than the system's internal preset system default parameter space. It integrates and outputs the final configuration object as the merged parameters, and uses a data verification framework that includes preset data type verification rules and numerical boundary verification rules to verify whether the data format of the final configuration object conforms to the preset data type verification rules, and whether the parameter values ​​of the final configuration object are within the range defined by the numerical boundary verification rules. The mode verification is completed when both verifications pass.

10. A material autonomous discovery system based on a large language model according to claim 8, characterized in that, The buffer scheduling module includes a background daemon module. The background daemon module continuously polls the storage path to be processed, calls the underlying file renaming interface of the operating system, forms a mutex lock with exclusive processing rights in a multi-process concurrent computing environment, executes the atomic move instruction to change the path prefix of the configuration file to the running storage path, and moves the configuration file to the running storage path. When performing the iterative calculation, the calculation module reads the material dataset according to the configuration file, extracts the three-dimensional spatial structure data containing the three-dimensional coordinate data and atomic number data of atoms, calculates the Euclidean distance between nodes based on the three-dimensional coordinate data of atoms, expands the basis function set within a set cutoff radius and uses a cosine smoothing cutoff function to control the continuous decay of the boundary, outputs predicted energy data based on the basis function set and the atomic number data, and calculates the negative gradient of the predicted energy data with respect to the three-dimensional coordinates of the atoms to obtain predicted force data, obtains the true potential energy data and true force data calculated by first principles, and establishes a joint energy-force loss function based on the predicted energy data, the predicted force data, the true potential energy data, and the true force data.

Images