Complex design method based on full history data retention strategy and electronic device

Abstract

The present application relates to the field of computational chemistry, in particular to the optimization of design accuracy and efficiency in the computational design process of transition metal chromophores. The purpose of the present application is to provide a complex design method based on a full history data retention strategy, which not only retains the failure data of the iteration process, but also classifies and differentially processes the failure data. The information overload and noise interference situation under the full history data retention strategy is changed, and the learning efficiency and reasoning quality of LLM are improved.

Description

Technical Field

[0001] This invention relates to the field of computational chemistry, specifically to optimizing the design accuracy and efficiency in the computational design process of transition metal chromophores. Background Technology

[0002] Functional transition metal complexes (TMCs) are molecular entities formed by the coordination of a transition metal central ion with one or more ligands. These compounds are core materials in many modern technologies, widely used in catalysis, optoelectronic materials, and medical diagnostics and treatment. Current technologies require the design of TMCs. This design process targets specific functions, such as maximizing the HOMO-LUMO band gap to improve photostability, and identifies or generates candidate molecular structures with optimal performance through calculation and optimization within TMC's near-infinite chemical space.

[0003] In existing technologies, design systems for TMCs primarily utilize genetic algorithms combined with machine learning. The design process is an iterative loop: generating candidate molecules, calculating their properties, and then generating a new generation of candidate molecules based on these properties. This continuous iteration and loop generates candidate molecules with optimal performance. Two main strategies exist in this iterative process: elitism retention and full historical data retention. The elitism retention strategy retains only a small number of candidate individuals with the highest fitness in each iteration, such as the Top 20 TMCs, as the basis for subsequent crossover and mutation iterations. However, this strategy's optimization relies entirely on limited successful experiences, systematically discarding the vast majority of failure data generated throughout the exploration process. Discarding this information means that each iteration may repeatedly explore known ineffective regions, resulting in a waste of resources and information.

[0004] Therefore, the full history data preservation strategy has gradually become the mainstream approach in system design. This strategy retains and utilizes all evaluated candidate molecule data during the iteration process, regardless of their performance. Furthermore, with technological advancements, the introduction of large-scale computing and LLM (Limited Least Mechanics) has made the efficiency of the full history data preservation strategy quite considerable.

[0005] However, while this strategy avoids information loss, it indiscriminately and unstructuresly mixes success and failure cases and provides them to the model, resulting in redundant information entropy. That is, the massive amount of failure data drowns out the relatively sparse success signals. LLM models require significant computational resources and context length to process this noisy, low-information-density data, increasing the cognitive load on the model. Summary of the Invention

[0006] The purpose of this invention is to provide a coordination design method based on a full-history data retention strategy. This method not only retains failed data from the iteration process but also categorizes and differentiates these failed data. This overcomes the information overload and noise interference issues inherent in the full-history data retention strategy, thereby improving the learning efficiency and inference quality of LLM.

[0007] In a first aspect, the present invention provides a coordination design method based on a full historical data retention strategy, characterized by comprising the following steps: collecting all historical samples and constructing an unsuccessful sample pool from the unsuccessful historical samples;

[0008] All samples in the non-successful sample pool are identified for failure reasons and divided into structural failure samples and performance failure samples. The structural failure samples are those that do not conform to the reasonable rules of chemical structure. The performance failure samples are those whose target attribute value P is lower than the preset target attribute threshold T_target.

[0009] A performance correlation model is constructed based on the aforementioned performance failure samples, and design strategies are provided for the design of new coordination compounds.

[0010] In a second aspect, the present invention provides an electronic device, including a processor and a memory; the processor is connected to the memory.

[0011] The memory is used to store executable program code; the processor reads the executable program code stored in the memory to run a program corresponding to the executable program code, so as to execute the method described above.

[0012] In summary, the present invention has the following beneficial effects:

[0013] 1. By constructing a pool of unsuccessful samples and finely classifying the reasons for failure, a complete retention and systematic utilization of all historical exploration experience was achieved. This overcomes the information waste problem caused by traditional genetic algorithms that only retain elite samples, laying a comprehensive knowledge foundation for the subsequent construction of data-driven performance correlation models, thereby significantly improving the knowledge reuse rate and optimization efficiency of the coordination compound design process.

[0014] 2. By jointly determining the validity of the global status code and the target attribute value P, accurate and automated identification of unsuccessful samples is achieved. Adding a separate category for technical failure samples allows for a more refined classification of the root causes of failure. This classification effectively isolates failures caused by non-chemical issues such as system environment and computing resources from genuine design failures, avoiding interference from invalid noise data on the learning of chemical design principles, and improving the purity and reliability of subsequent performance correlation model training.

[0015] 3. A multi-channel classifier employing serial logic enables an efficient and accurate failure root cause diagnosis process. This sequential judgment logic simulates a diagnostic approach that proceeds from the surface to the core, prioritizing the filtering of technical noise, then assessing structural rationality, and finally evaluating performance gaps. This significantly improves the efficiency and accuracy of the classification operation while ensuring the logical rigor of the diagnostic process.

[0016] 4. By establishing clear chemical rationality rules, such as bond length, coordination number, and interatomic spacing, objective and quantifiable automatic criteria for identifying structural failures are provided. Design schemes that violate fundamental chemical principles are screened and eliminated early on, avoiding unnecessary waste of performance calculation resources in the later stages.

[0017] 5. The root mean square deviation (RMSD) of the structure before and after geometric optimization is introduced as an auxiliary criterion, enhancing the sensitivity of detection of potential structural problems. This effectively identifies molecules that, although passing static rule checks, have unstable actual structures, reducing the risk of false positives and false negatives in structural failures, and making structural screening more comprehensive and robust.

[0018] 6. Identified structural failure samples are transformed into design taboo rules. These rules can directly guide large-scale language models (LLMs) to proactively avoid known invalid structural regions when generating new solutions, thereby significantly improving the structural rationality and success rate of generated molecules.

[0019] 7. Construct performance correlation models and multiple linear regression models to quantify the structure-performance relationships implicit in performance failure samples. This reveals the direction and intensity of the influence of different molecular descriptors on performance gaps, providing data-supported, quantifiable strategies for optimized design, thus achieving a leap from qualitative guidance to quantitative optimization.

[0020] 8. The performance deficiency R is graded and sub-models are established. Based on the predicted performance shortcomings of the new molecule design, the most relevant optimization sub-model is automatically matched to provide a more targeted design strategy that is adapted to the degree of failure, thereby improving the accuracy and efficiency of optimization recommendations. Attached Figure Description

[0021] Figure 1 Flowcharts illustrating coordination design methods based on a full history data retention strategy, representing several embodiments of this specification, are shown.

[0022] Figure 2 Sub-flowcharts illustrating the process of filtering out unsuccessful sample pools according to several embodiments of this specification are shown;

[0023] Figure 3 Sub-flowcharts illustrating various embodiments of this specification are shown for identifying structural, performance, and technical failure samples;

[0024] Figure 4A schematic diagram of the structure of an electronic device according to some embodiments of this specification is shown. Detailed Implementation

[0025] The present invention will be further described in detail below with reference to the accompanying drawings.

[0026] The technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings.

[0027] The terms "first," "second," "third," etc., in the description, claims, and accompanying drawings are used to distinguish different objects, not to describe a specific order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or apparatus that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to such processes, methods, products, or apparatus.

[0028] The following description provides examples and does not limit the scope, applicability, or examples set forth in the claims. Changes may be made to the function and arrangement of the described elements without departing from the scope of this specification. Various processes or components may be appropriately omitted, substituted, or added to the examples. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Furthermore, features described with respect to some examples may be combined into other examples.

[0029] Figure 1 The flowcharts of future community planning based on a quantitative data system for several embodiments of this specification are shown. The following example uses the design task of designing TMC molecules that maximize the HOMO-LUMO band gap as an example.

[0030] The specific operation steps of this method 100 are as follows.

[0031] In box 101, method 100 is used for data acquisition and to establish a pool of unsuccessful samples.

[0032] This step is a crucial initial step in the transition metal complex (TMC) design process based on a quantitative data system. As a quality control entry point, it is responsible for initially screening out all potentially problematic samples from a large number of TMC calculation samples.

[0033] Figure 2 The specific sub-steps of this step are shown.

[0034] First, in box 1011, the TMC molecule calculation results for all training materials are obtained. These data are derived from the output of quantum chemistry calculation software, such as GFN2-xTB. These calculation results include the global state code and target attribute values ​​for each TMC molecule.

[0035] For example, each TMC molecule is denoted as TMC_i, where i is the sample index, the global status code is denoted as Status_i, and the target attribute value is P_i, such as the HOMO-LUMO bandgap exemplified in this embodiment.

[0036] The status code Status_i indicates the execution status of the computation task. Common values ​​include "Success", "Error", and "NotConverged". The attribute value P_i is numeric data. If the computation fails, it may be NaN, which is not a numeric value.

[0037] Subsequently, in box 1012, a preliminary judgment is made on each TMC sample.

[0038] For example, the failure flag function F(TMC_i) is executed to perform a preliminary judgment on each TMC sample. The function is defined as a logical expression:

[0039] F(TMC_i) = (Status_i != "Success") OR (P_i is NaN)

[0040] in:

[0041] TMC_i: Represents the i-th TMC sample. Status_i: The global status code returned by the computation task; anything other than "Success" is a trigger flag. P_i: The target attribute value; if it is NaN, it is a trigger flag.

[0042] The function application process involves the CPU sequentially processing each sample, checking if Status_i is "Success" and if P_i is a numerical value. If either condition is true, F(TMC_i) returns true, indicating that the sample is marked as "unsuccessful"; otherwise, it returns false. For ease of explanation, let's take 10 TMC samples as an example, and calculate as follows:

[0043] TMC1: Status_i = "Success", P_i = 4.5 → F = false

[0044] TMC2: Status_i = "Error", P_i = NaN → F = true

[0045] TMC3: Status_i = "Success", P_i = 3.8 → F = false

[0046] TMC4: Status_i = "NotConverged", P_i = NaN → F = true

[0047] TMC5: Status_i = "Success", P_i = 5.2 → F = false

[0048] TMC6: Status_i = "Success", P_i = 2.9 → F = false

[0049] TMC7: Status_i = "Error", P_i = NaN → F = true

[0050] TMC8: Status_i = "Success", P_i = 4.1 → F = false

[0051] TMC9: Status_i = "Success", P_i = NaN → F = true

[0052] TMC10: Status_i = "Success", P_i = 4.7 → F = false.

[0053] This step achieves rapid preliminary screening through simple logical operations. Its advantages lie in its low algorithm complexity and minimal computational overhead, making it suitable for large-scale data scenarios. Furthermore, because it relies solely on status codes and numerical validity, it avoids subjective threshold settings, ensuring the objectivity of the screening process.

[0054] Box 1013, Generation of unsuccessful sample pool

[0055] Samples where F(TMC_i) is true are aggregated into a list of unsuccessful samples and stored in the memory subsystem or persisted to a storage device. The list includes the sample index, Status_i, and P_i value for easy retrieval in subsequent steps.

[0056] Based on the above example, the unsuccessful samples include TMC2, TMC4, TMC7, and TMC9.

[0057] Unsuccessful samples: [2, 4, 7, 9]

[0058] TMC2: Status=Error, P_i=NaN

[0059] TMC4: Status=NotConverged, P_i=NaN

[0060] TMC7: Status=Error, P_i=NaN

[0061] TMC9: Status=Success, P_i=NaN

[0062] A high-recall pool of unsuccessful samples is generated in box 1013, containing all samples with computational anomalies or invalid data. This approach, on the one hand, minimizes the risk of missed detections by using lenient criteria, such as including TMC9 even if its state is successful but P_i is NaN, thus providing a complete data foundation for subsequent refined classification. On the other hand, the clear list structure supports batch processing, improving the overall efficiency of the process.

[0063] As the starting point of method 100, the output of box 101 is directly fed into box 102, providing a clean data input for the entire LLM-EO framework.

[0064] Step 102 is a core processing step in the transition metal complex (TMC) design flow. This step is responsible for accurately diagnosing the unsuccessful samples initially screened in Step 101, determining their root causes, and classifying them as technical failures, structural failures, or performance failures.

[0065] like Figure 3 As shown, Figure 3 This is a sub-step of box 102. First, box 1021 is for data loading and initialization. The pool of unsuccessful samples generated in box 101 is loaded from the memory subsystem or storage device; this pool exists as a list. This list contains the index, status code Status_i, and target attribute value P_i for each sample.

[0066] For example, at the same time, the system initializes a classification rule base, including a keyword base for technical failures, such as "Error" and "NotConverged"; a chemical rule base for structural failures, such as reasonable bond length ranges and expected coordination number values; and threshold parameters for performance failures, such as the target attribute threshold T_target.

[0067] The classification rules are pre-stored in the storage device and loaded into memory by the CPU for fast access.

[0068] In box 1022, unsuccessful samples are classified and diagnosed. Each unsuccessful sample is determined as either a technical failure, a structural failure, or a performance failure.

[0069] The three assessments can be performed simultaneously or in different time sequences. In some preferred embodiments, the CPU executes a multi-channel classifier to perform three levels of diagnosis on each unsuccessful sample, in the order of technicality, structure, and performance.

[0070] As mentioned above, the classifier uses a cascaded logic: first, it detects technical failures, then structural failures, and finally, it evaluates performance failures. Each channel is judged independently, and once a sample is classified, subsequent channels are skipped to ensure efficiency. The following uses TMC2, TMC4, TMC7, and TMC9 as examples to explain the classification process in detail.

[0071] Channel 1: Classification of technical failures.

[0072] This channel is designed to identify failures caused by system-level errors. The CPU uses regular expressions to match keywords in Status_i; for example, a match for "Error," "Timeout," or "NotConverged" is marked as a technical failure. The algorithm is formalized as follows:

[0073] IF (Status_i matches technical error keywords) THEN Label = "Technical_Failure"

[0074] For example:

[0075] TMC2: Status_i = "Error" → Matches the keyword "Error" → Label = Technical_Failure

[0076] TMC4: Status_i = "NotConverged" → Matches the keyword "NotConverged" → Label= Technical_Failure

[0077] TMC7: Status_i = "Error" → Matches the keyword "Error" → Label = Technical_Failure

[0078] TMC9: Status_i = "Success" → No match for any technical error keywords → Proceed to the next channel.

[0079] The advantage of this channel is that it quickly filters system noise, preventing irrelevant errors from interfering with subsequent chemical analyses. In terms of performance, it identifies obvious external failures, such as TMC2, TMC4, and TMC7, with high classification accuracy. TMC9, however, is not a technically flawed sample and proceeds to the next channel.

[0080] Channel Two: Structural Failure Classification

[0081] For samples not classified as technical failures, the CPU calls the chemical rule base to perform structural rationality checks.

[0082] For example, the rules include: whether the bond length is within a reasonable range, such as the Pd-L bond length range of 1.8-2.2 Å; whether the coordination number matches the expected value, such as the coordination number of Pd(II) being 4; and whether the interatomic distance is less than the sum of the van der Waals radii.

[0083] The algorithm can be formalized as:

[0084] IF (exists bond length ∉ [reasonable range] OR coordination number ≠ expected value OR interatomic distance < sum of van der Waals radii) THEN Label = "Structural_Failure".

[0085] Example: TMC9: Status_i = "Success", P_i = NaN. Checking its structural data: bond lengths are [1.7, 2.0, 2.1, 2.3] Å, where 1.7 Å < the reasonable lower limit of 1.8 Å → violates the rule → Label = Structural_Failure

[0086] Furthermore, to enhance accuracy, the system calculates the root mean square deviation (RMSD) of the structure before and after molecular geometry optimization. If the RMSD > a threshold (e.g., 0.5 Å), the structural failure determination is strengthened.

[0087] RMSD stands for Root Mean Square Deviation. It measures the overall change in the spatial positions of atoms in a molecule before and after geometric optimization. A smaller RMSD value indicates that the optimized structure is more similar to the initial structure; a larger RMSD value indicates that the structure has undergone drastic changes during the optimization process. In this invention, RMSD serves as evidence for the first three criteria.

[0088] For example, some molecules may have an initial structure that passes the first three static checks—that is, all bond lengths, coordination numbers, and atomic distances are within the threshold—but their configuration may be in an unstable high-energy state. During geometry optimization, it will relax to a completely different stable structure. In this case, the RMSD before and after optimization will be abnormally high, for example, 0.8 Å.

[0089] A high RMSD serves as a warning signal, indicating that although the molecule passes the static check, its structure is extremely unstable and may contain complex structural problems not covered by the rule base, such as an unreasonable torsion angle or incorrect weak interaction sites. In such cases, the system can mark it as a suspected structural failure and suggest manual review or direct classification as a failure to avoid passing the unstable structure to subsequent steps.

[0090] The effectiveness of this channel lies in identifying fundamental chemical design errors. Through a rule base and RMSD assistance, it provides objective structural diagnostics, avoiding subjective misjudgments. For example, bond length anomalies in TMC9 were accurately captured, providing a clear direction for subsequent design optimization.

[0091] Channel 3: Performance Failure Classification.

[0092] For samples that pass through the first two channels, the CPU evaluates whether their performance meets the target. The system compares P_i with a preset threshold T_target, such as a HOMO-LUMO bandgap threshold of 3.0 eV. If P_i < T_target, it is marked as a performance failure. The algorithm is formalized as follows:

[0093] IF (P_i < T_target) THEN Label = "Performance_Failure"

[0094] For example: Suppose there is a sample TMCX not included in this example, with Status_i = "Success", P_i = 2.5eV. Since 2.5 eV < T_target (3.0 eV) → Label = Performance_Failure.

[0095] Box 1023: Classification Result Generation and Output

[0096] The CPU aggregates the classification results of all samples and generates a classification report, including the final label and confidence score for each sample. The report is stored in the memory subsystem and can be displayed via an output device, such as a screen.

[0097] In this step, on the one hand, the multi-channel design covers three reasons for failure: system errors, violations of chemical rules, and insufficient performance, encompassing different types of errors and clearly categorizing them. On the other hand, the judgment is made in the order of technical, structural, and performance-related. This is because the judgment of technical failures is based on the metadata returned by the computation task; such checks are lightweight operations with extremely low computational overhead. Placing them first can quickly identify and filter out failure samples caused by non-chemical reasons such as system environment and insufficient computing resources, improving the efficiency of the overall classification process. Subsequently, structure is considered before performance. A molecule must first meet the structural rationality before discussing its performance is meaningful. Placing structural checks before performance checks can accurately distinguish between failures caused by inherent defects and failures caused by poor design, avoiding misjudging structural problems as performance problems, thereby ensuring the accuracy of root cause diagnosis.

[0098] This progressive three-level diagnostic process peels away the causes of failure of different natures layer by layer, ultimately achieving efficient, accurate, and interpretable automated classification of unsuccessful samples, laying a solid and reliable data foundation for the intelligent optimization of the entire LLM-EO framework.

[0099] The next step is box 103, which involves knowledge extraction and closed-loop design guidance. This is the decision-making stage in the transition metal complex (TMC) design process. It is responsible for transforming the refined classification results output from box 102 into structured knowledge that can guide large-scale language model (LLM) design for next-generation TMC.

[0100] First, the classification result list output by box 102 is loaded from memory. Then, the system initializes three independent knowledge bases, corresponding to three types of unsuccessful samples: Technical_Failure, Structural_Failure, and Performance_Failure.

[0101] Each knowledge base exists in the storage device as a structured database table, containing fields such as sample ID, failure category, specific reason description, and relevant molecular features, including the SMILES string and abnormal key length values. Taking the example output of box 102, the initial records of the constructed knowledge base are as follows:

[0102] Technical Failure Knowledge Base: Records TMC2 (reason: system error), TMC4 (reason: non-convergence), and TMC7 (reason: system error).

[0103] Structural Failure Knowledge Base: Record TMC9 (Cause: Abnormal Pd-L bond length, measured value 1.7 Å, reasonable lower limit 1.8 Å).

[0104] Performance failure knowledge base: (No records in this example; assume there is a sample TMCX, P_i=2.5 eV, threshold T_target=3.0 eV).

[0105] Subsequently, the CPU extracts knowledge from the records in the knowledge base and generates executable guidance rules. The extraction process employs differentiated strategies for different knowledge bases:

[0106] Extracting design taboo rules from a structural failure knowledge base: The CPU performs cluster analysis on the records in the knowledge base, extracts common structural error patterns, and transforms them into explicit taboo clauses. The algorithm uses frequent pattern mining (such as the Apriori algorithm) to find frequently occurring abnormal structural features.

[0107] This step abstracts specific failure cases into universal design constraints. The advantage is that it enables LLM to directly understand and avoid a certain type of fundamental structural error, significantly reducing the probability of generating invalid molecules.

[0108] Build a performance correlation model from a performance failure knowledge base.

[0109] For performance failure samples, the CPU performs statistical analysis to establish a correlation model between molecular structural features and performance gaps. This model aims to establish a quantitative relationship between molecular structural features and target performance gaps, thereby transforming discrete failure cases into predictable and actionable design rules.

[0110] For example, a mathematical mapping function F is established such that, for any given molecular structure, the performance gap relative to the target can be predicted based on its key features, i.e.:

[0111] Performance gap = F (molecular structural characteristics)

[0112] Multiple linear regression can be used as the basic modeling tool here. The regression coefficients can directly reflect the contribution and direction of influence of each descriptor, making them suitable for guiding knowledge extraction.

[0113] Select a sufficient number of representative samples from the performance failure knowledge base. For example, select 100 performance failure TMC samples accumulated in past optimization loops to form the training set {TMC_i}, i=1,2,...,100.

[0114] Next, the dependent variable is defined. For each sample TMC_i, its performance gap D_i is calculated. D_i = T_target - P_i, where T_target is the preset performance target value, such as 4.0 eV for the HOMO-LUMO bandgap, and P_i is the actual performance value calculated for that sample.

[0115] Select and calculate independent variables. For each sample, calculate a set of predefined molecular descriptors, i.e., independent variables. These descriptors should comprehensively reflect the geometric, electronic, and topological properties of the molecule. For example: X1: Average electronegativity - reflects the overall electron attraction of the molecule. X2: Topological polar surface area - reflects the polarity of the molecule and solvent accessibility.

[0116] In some embodiments, this can be extended to more descriptors, such as X3: molecular weight, X4: dipole moment, etc. All descriptors can be standardized, such as by Z-score standardization, to eliminate the influence of dimensions and ensure the comparability of regression coefficients.

[0117] Establish a multiple linear regression model:

[0118] D = β0 + β1*X1 + β2*X2 + ... + βk*Xk

[0119] Where D represents the performance gap, X1, X2, ..., Xk are k standardized molecular descriptors, β0 is the intercept term, and β1, β2, ..., βk are the partial regression coefficients to be estimated.

[0120] The least squares method can be used for parameter estimation. The optimization objective of this method is to find a set of coefficients β0, β1, ..., βk such that the model predicts... Sum of squared residuals between the true value D and the actual value D To reach a minimum. This process can be efficiently performed using standard statistical software or scientific computing libraries, such as scikit-learn in Python. For example, the coefficients β1 = -0.5 and β2 = 0.1 are calculated.

[0121] The coefficient sign indicates the direction of influence. β1 = -0.5 < 0 indicates that, controlling for other factors, for every standard deviation increase in mean electronegativity (X1), the predicted performance gap will decrease by 0.5 units. This means that higher mean electronegativity helps to narrow the performance gap, i.e., improve molecular performance. Conversely, β2 = 0.1 > 0 indicates that an increase in TPSA (X2) will widen the performance gap and have a negative impact on performance.

[0122] The absolute values ​​of the coefficients represent the intensity of the influence. |β1| = 0.5 > |β2| = 0.1, indicating that in the current model, the influence of average electronegativity on the performance gap is much stronger than that of TPSA. The core function of this performance correlation model is to quantify and regularize historical failure experience. For example, based on the above model, the strategy that can be extracted is: "When designing new TMCs, priority should be given to selecting ligands or structural segments with high average electronegativity, while avoiding the introduction of excessively large topological polar surface areas to effectively improve the HOMO-LUMO bandgap."

[0123] When the linear assumption does not hold, nonlinear models, such as support vector regression, Gaussian process regression, or simple neural networks, can be used to capture more complex relationships. When the number of descriptors is large, regularized regression techniques such as Lasso or Ridge can be introduced to automatically select features, improving the model's generalization ability and interpretability.

[0124] This step transforms performance failures into quantifiable optimization directions, providing LLM with data-driven, rather than just intuitive, optimization suggestions, guiding it to make evidence-based structural adjustments, and improving the scientific rigor and efficiency of the optimization process.

[0125] Handling of technical failure knowledge base:

[0126] Technical failure samples are not usually used directly to generate design rules, but their records are used for system operation and maintenance and computational task scheduling optimization. For example, identifying a certain type of computational task that is prone to "memory overflow" can help avoid it in subsequent task allocation.

[0127] Finally, dynamic prompt generation and closed-loop guidance.

[0128] The CPU transforms the extracted rules into natural language instructions, dynamically generates prompts for the LLM, and sends them to the LLM.

[0129] For example, the prompt adopts a structured format, explicitly divided into two parts: background knowledge and design task. The design task remains unchanged; for instance, it still aims to generate n new TMC molecule design schemes, with the goal of maximizing the HOMO-LUMO band gap. However, the background knowledge includes the extraction of design taboo rules from the structural failure knowledge base mentioned above, the construction of a performance correlation model from the performance failure knowledge base, and the extraction of new TMC design strategies based on the performance correlation model.

[0130] By using natural language instructions, failure experiences are directly transformed into LLM design constraints and optimization goals, making the proposals more targeted. The TMC molecule generated by LLM based on the new prompts will be recalculated and evaluated. The result, whether successful or not, will be fed back to box 101, starting a new round of optimization cycle, thus forming a closed-loop system of continuous improvement.

[0131] In some embodiments, there is also an inventive concept design of sub-models based on performance gaps, which mainly exists in block 103.

[0132] The core idea of this inventive concept design is to classify according to the performance gap degree in the performance failure knowledge base described above. Samples under different classifications each have a corresponding sub-performance association model at their respective levels.

[0133] Specifically, calculate the performance deficiency degree R of each sample in the performance failure knowledge base.

[0134] ,

[0135] R is the performance deficiency degree, representing the degree of deficiency of the actual performance relative to the target performance.

[0136] T_target is the target performance value. For example, the target of the HOMO-LUMO energy gap is 4.0 eV. P_actual: The performance value actually calculated for the sample.

[0137] The classification standard is divided based on the value of R. Engineering designers can classify according to the actual situation. Exemplarily, some embodiments have made a three-level classification: L1 mild failure: 0 < R ≤ 0.25. L2 moderate failure: 0.25 < R ≤ 0.5. L3 severe failure: R > 0.5.

[0138] Subsequently, a separate sub-regression model is constructed for each classification.

[0139]

[0140] The idea design of the formula is the same as above, where R is the performance deficiency degree, X1, X2,..., Xp are p standardized molecular descriptors, k is the label number of the sub-model, which is 1, 2, 3 in this embodiment. β0 is the intercept term, and β1, β2,..., βp are the partial regression coefficients to be estimated.

[0141] Use all the sample data at the L1 level to calculate the parameters of the sub-model No. 1, and the same applies to sub-models No. 2 and No. 3.

[0142] This will generate three independent prediction equations. Exemplarily, the equations are:

[0143] Model_L1: R(1) = -0.3 - 0.6X1 + 0.1X2

[0144] Model_L2: R(2) = -0.1 - 0.3X1 + 0.2X2

[0145] Model_L3: R(3)=0.4 + 0.1X1 + 0.5X2.

[0146] Here, X1 is the average electronegativity; X2 is the topological polar surface area (TPSA).

[0147] This means that at L1 level, the coefficient of average electronegativity X1 is -0.6, which is the largest absolute value. This indicates that when approaching success, increasing electronegativity is the most effective lever to reduce the relative performance deficit R, i.e., to improve performance.

[0148] At level L3, the coefficient of topological polar surface area X2 is +0.5, which is the largest and positive. This indicates that for molecules with severe problems, increasing X2 will significantly increase the relative performance deficiency R, making it the primary avoidance factor.

[0149] This step transforms the above analysis results into a hierarchical design strategy that can be implemented by LLM.

[0150] Based on model interpretation, customized natural language instructions are generated for each failure level. When LLM generates a new candidate molecule Mnew, the system first calculates its descriptors X1new and X2new. Subsequently, it calculates the performance missingness Rnew of the candidate molecule Mnew and calls the corresponding policy library to generate hints.

[0151] For example, if Rnew = 0.18, indicating a minor failure, Model_L1 is invoked. An example prompt for the LLM would be: "Current design estimate is close to performance target, L1 risk." The L1 model indicates that maximizing the average electronegativity X1 is critical for a performance sprint, with a coefficient of -0.6. Introducing strong electron-withdrawing groups, such as -CF3, is preferred, increasing X1 to ≥5.0.

[0152] For example, if Rnew=0.55, indicating severe failure, then Model_L3 is invoked. For instance, the prompt for the LLM is: "The current design is projected to have a high-performance failure risk at level L3. The L3 model indicates that the current structural mode yields minimal benefit from reducing the average electronegativity X1 (coefficient 0.1), and the primary task is to significantly reduce the topological polar surface area (X2) (coefficient 0.5). A shift towards a rigid, compact molecular framework is recommended."

[0153] Under this approach, the instructions obtained by LLM are highly matched with the estimated maturity of the current design draft, thereby significantly improving optimization efficiency, avoiding lingering in the ineffective design space, and stimulating innovative solutions for problems of different complexities.

[0154] Figure 4 A block diagram of an electronic device 300 that can implement various embodiments of the present disclosure is shown. For example... Figure 4 As shown, device 300 includes a processor 301, which can perform various appropriate actions and processes based on computer program instructions loaded into random access memory (RAM) 303 according to computer program instructions stored in read-only memory (ROM) 302. RAM 303 may also store various programs and data required for the operation of device 300. The processor 301, ROM 302, and RAM 303 are interconnected via bus 304. Input / output (I / O) interface 305 is also connected to bus 304.

[0155] The various processes and procedures described above, such as method 100, can be executed by processor 301. For example, in some embodiments, method 100 may be implemented as a software program tangibly contained in a machine-readable medium. In some embodiments, part or all of the software program may be loaded and / or installed on device 300 via ROM 302. When the software program is loaded into RAM 303 and executed by processor 301, one or more actions of method 300 described above may be performed.

[0156] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0157] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. Furthermore, although operations are depicted in a specific order, this should be understood as requiring that such operations be performed in the specific order shown or in sequential order, or requiring that all illustrated operations be performed to achieve the desired result. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the foregoing discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single implementation. Conversely, various features described in the context of a single implementation may also be implemented individually or in any suitable sub-combination in multiple implementations.

[0158] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. A coordination compound design method based on a full history data retention strategy, characterized in that, The process includes the following steps: collecting all historical samples and constructing a pool of unsuccessful historical samples from them; All samples in the non-successful sample pool are identified for failure reasons and divided into structural failure samples and performance failure samples; the structural failure samples are those that do not conform to the reasonable rules of chemical structure. Based on the structural failure samples, abnormal structural features are extracted, and design taboo rules are provided for the design of new coordination compounds according to the abnormal structural features. The performance failure samples are those where the target attribute value P is lower than the preset target attribute threshold T_target; a performance correlation model is constructed based on the performance failure samples, and design strategies are provided for new coordination compound designs; Select multiple performance failure samples to form a training set; For each sample TMC_i in the training set, calculate its performance gap D_i, D_i = T_target - P_i; Establish a regression model: D = β0 + β1*X1 + β2*X2 + ... + βk*Xk; where X1, X2... Xk are k standardized molecular descriptors, β0 is the intercept term, and β1, β2, ..., βk are the partial regression coefficients to be estimated; The optimal partial regression coefficients are calculated using the least squares method, and the regression model containing the optimal partial regression coefficients is defined as the performance correlation model. The performance correlation model provides design strategies for new coordination compound designs.

2. The coordination compound design method based on a full history data retention strategy according to claim 1, characterized in that: The process of collecting all historical samples and constructing a non-successful sample pool from the unsuccessful historical samples is as follows: Obtain all historical samples, each containing the global status code and target attribute value P of the TMC molecule; If the target attribute value P is not a numerical value, or if the global status code is not a success identifier, then the historical sample is determined to be an unsuccessful historical sample.

3. The coordination compound design method based on a full history data retention strategy according to claim 2, characterized in that: The process involves identifying the causes of failure in all samples within the unsuccessful sample pool, categorizing them into structural failure samples and performance failure samples. This also includes... The samples are classified as technical failures, which are failures caused by errors in the system itself during the calculation process and are identified by reading the global status code.

4. The coordination compound design method based on a full history data retention strategy according to claim 3, characterized in that: The failure reason identification for all samples in the unsuccessful sample pool is specifically achieved through a multi-channel classifier. The multi-channel classifier uses serial logic to sequentially judge technical, structural, and performance reasons.

5. The coordination compound design method based on a full history data retention strategy according to any one of claims 1-4, characterized in that: The identification criteria for structural failure samples are: whether the bond length is within a preset range, whether the coordination number matches a preset value, or whether the interatomic distance is less than the sum of van der Waals radii.

6. The coordination compound design method based on a full history data retention strategy according to claim 5, characterized in that: If a non-successful sample is not identified as a structural failure, the root mean square deviation (RMSD) of the molecular structure before and after geometry optimization is calculated. If it exceeds a preset threshold, it is marked as a suspected structural failure.

7. The coordination compound design method based on a full history data retention strategy according to claim 1, characterized in that: Calculate the performance missing degree R for each sample in the performance failure library, R = (T_target - P_actual) / T_target, where P_actual is the actual performance value of the sample. Based on the R value, classify the degree of performance failure, and obtain a sub-performance association model for each classification. The performance deficiency degree Rnew is calculated for the new coordination molecule Mnew generated by the design system, and the corresponding sub-performance correlation model is selected based on Rnew to provide design strategy.

8. An electronic device, comprising a processor and a memory; the processor being connected to the memory; The memory is used to store executable program code; the processor runs a program corresponding to the executable program code by reading the executable program code stored in the memory, so as to perform the method as described in any one of claims 1 to 7.

Images